Struct WorkspaceServices 

pub struct WorkspaceServices { /* private fields */ }

The host-provided workspace capability bundle used by tool execution.

Implementations

impl WorkspaceServices

pub fn with_remote_git( self: Arc<Self>, config: RemoteGitBackendConfig, ) -> Result<Arc<Self>>

Attach a remote git provider to an existing super::WorkspaceServices.

Returns a new Arc<WorkspaceServices> with git and git_stash wired to the remote backend. The original WorkspaceServices is not mutated. git_worktree is intentionally reset to None — worktrees are a local-filesystem concept that does not map cleanly onto a remote service (see RFC §8). All other fields — including local_root, the command runner, the search provider, the optional file_system_ext (S3 CAS), and operation_timeout — are preserved verbatim via the internal with_git_provider constructor.

impl WorkspaceServices

pub fn builder( workspace_ref: WorkspaceRef, file_system: Arc<dyn WorkspaceFileSystem>, ) -> WorkspaceServicesBuilder

pub fn local(root: impl Into<PathBuf>) -> Arc<Self>

pub fn local_with_manifest(root: impl Into<PathBuf>) -> Arc<Self>

Local workspace services backed by an in-memory file manifest for search. read/write/ls/bash/git preserve local backend behavior; glob and grep use the manifest once the initial scan has completed and fall back to filesystem search before that.

pub fn local_with_retrieval(root: impl Into<PathBuf>) -> Arc<Self>

Build local manifest services with an asynchronous ephemeral catalog.

pub async fn local_with_code_intelligence( root: impl Into<PathBuf>, isolation_scope: impl Into<String>, ) -> Result<Arc<Self>>

Build local manifest-backed services with native Code Intelligence.

The provider subscribes to the manifest’s existing change stream and therefore does not create a second filesystem watcher or file index.

pub async fn local_with_retrieval_and_code_intelligence( root: impl Into<PathBuf>, isolation_scope: impl Into<String>, ) -> Result<Arc<Self>>

Build one local session with retrieval and Code Intelligence sharing the same manifest scanner and filesystem change stream.

pub async fn local_with_code_intelligence_backend( backend: Arc<ManifestWorkspaceBackend>, isolation_scope: impl Into<String>, ) -> Result<Arc<Self>>

Attach native Code Intelligence to one shared manifest backend.

pub async fn local_with_retrieval_and_code_intelligence_backend( backend: Arc<ManifestWorkspaceBackend>, isolation_scope: impl Into<String>, ) -> Result<Arc<Self>>

Attach retrieval and Code Intelligence to one shared manifest backend.

pub fn local_with_manifest_backend( backend: Arc<ManifestWorkspaceBackend>, ) -> Arc<Self>

Build local workspace services from a shared manifest backend. Hosts can keep the same manifest for UI file pickers and agent tools.

pub fn local_with_retrieval_backend( backend: Arc<ManifestWorkspaceBackend>, ) -> Arc<Self>

Enable retrieval on a shared manifest backend.

pub fn workspace_ref(&self) -> &WorkspaceRef

pub fn capabilities(&self) -> WorkspaceCapabilities

pub fn normalize_path(&self, input: &str) -> Result<WorkspacePath>

pub fn fs(&self) -> Arc<dyn WorkspaceFileSystem>

pub fn fs_ext(&self) -> Option<Arc<dyn WorkspaceFileSystemExt>>

Optional compare-and-swap file system extensions.

Returns Some when the backend supports version-aware writes (e.g. S3 via ETag). Tools that perform read-modify-write cycles should route through Self::read_for_edit and Self::write_for_edit rather than touching this directly.

pub fn text_reader(&self) -> Option<Arc<dyn WorkspaceTextReader>>

pub fn command_runner(&self) -> Option<Arc<dyn WorkspaceCommandRunner>>

pub fn search(&self) -> Option<Arc<dyn WorkspaceSearch>>

pub fn code_intelligence(&self) -> Option<Arc<dyn WorkspaceCodeIntelligence>>

Optional workspace-scoped semantic code query provider.

pub fn chunk_catalog(&self) -> Option<Arc<WorkspaceChunkCatalog>>

Optional session-local catalog shared by lexical and semantic retrieval.

pub fn workspace_retrieval(&self) -> Option<Arc<WorkspaceRetrievalRuntime>>

Optional semantic retrieval runtime bound to this workspace session.

pub async fn semantic_search( &self, request: WorkspaceSemanticSearchRequest, cancellation: CancellationToken, ) -> WorkspaceRetrievalResult<WorkspaceSemanticSearchResult>

Search the session-owned semantic index and verify every returned source chunk against the workspace backend before exposing its text.

pub async fn hybrid_search( &self, request: WorkspaceHybridSearchRequest, cancellation: CancellationToken, ) -> WorkspaceRetrievalResult<WorkspaceHybridSearchResult>

Run exact, lexical, structural, and semantic retrieval against one catalog revision, fuse channel ranks, and verify returned source text.

pub fn with_code_intelligence( &self, provider: Arc<dyn WorkspaceCodeIntelligence>, ) -> Arc<Self>

Attach a semantic code query provider while preserving every existing workspace capability and backend.

pub fn git(&self) -> Option<Arc<dyn WorkspaceGit>>

pub fn git_stash(&self) -> Option<Arc<dyn WorkspaceGitStashProvider>>

pub fn git_worktree(&self) -> Option<Arc<dyn WorkspaceGitWorktreeProvider>>

pub fn operation_timeout(&self) -> Option<Duration>

Default timeout applied to non-bash workspace operations.

None means no enforced timeout. Backends that may stall (remote, browser, DFS) should set this so tools using Self::run_with_timeout surface a timeout error instead of letting the agent loop hang.

pub async fn run_with_timeout<F, T, E>( &self, op: &'static str, fut: F, ) -> Result<T, E>

where F: Future<Output = Result<T, E>>, E: From<Error>,

Run a workspace future under the configured operation timeout.

Tools that route through file system / search / git providers should wrap their calls with this helper so non-local backends never stall the agent loop indefinitely.

Polymorphic in the error type so the helper works equally well for futures returning anyhow::Result<T> (the legacy callers — search, git, etc.) and for futures returning WorkspaceResult<T> (the migrated WorkspaceFileSystem callers). The E: From<anyhow::Error> bound is satisfied by both anyhow::Error (trivially) and WorkspaceError (via its #[from] Backend variant); a timeout surfaces as that From conversion of an anyhow!(...) message.

pub async fn read_for_edit( &self, path: &WorkspacePath, ) -> WorkspaceResult<(String, Option<String>)>

Read a file for a subsequent modify-write cycle, requesting a version token when the backend supports compare-and-swap writes.

Returns (content, Some(version)) when Self::fs_ext is available (e.g. on S3, where the version is the object ETag); (content, None) otherwise. Pair with Self::write_for_edit.

pub async fn write_for_edit( &self, path: &WorkspacePath, content: &str, expected_version: Option<&str>, ) -> WorkspaceResult<WorkspaceWriteOutcome>

Companion to Self::read_for_edit. Performs a compare-and-swap write when both Self::fs_ext is available and a version token was returned by the prior read; falls back to a plain write otherwise. On version mismatch the returned error is the typed WorkspaceError::VersionConflict variant; callers can also still downcast anyhow::Error::downcast_ref::<WorkspaceVersionConflict>() when the value has been lifted into an anyhow::Result.

pub fn local_root(&self) -> Option<&Path>

pub fn display_path(&self, path: &WorkspacePath) -> String

Trait Implementations

impl Debug for WorkspaceServices

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.