@qwen-code/web-shell 0.24.1-preview.0

package/dist/types/daemon/workspace/types.d.ts

@@ -0,0 +1,415 @@
+/**
+ * @license
+ * Copyright 2025 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { ReactNode } from 'react';
+import type { DaemonAgentMutationResult, DaemonAuthProviderId, DaemonAuthProviderCatalog, DaemonAuthProviderInstallRequest, DaemonAuthProviderInstallResult, DaemonAuthStatusSnapshot, DaemonCapabilities, DaemonChannelMutationResult, DaemonChannelPairingApprovalResult, DaemonChannelPairingApprovalsSnapshot, DaemonChannelPairingRequestsSnapshot, DaemonChannelPairingRevocationRequest, DaemonChannelPairingRevocationResult, DaemonChannelsSnapshot, DaemonChannelStartupRequest, DaemonChannelTypeCatalog, DaemonChannelUpsertRequest, DaemonClient, DaemonCreateAgentRequest, DaemonWorkspaceGenerationEvent, DaemonGeneratedAgentContent, DaemonDeviceFlowStartResult, DaemonDeviceFlowState, ExtensionMutationResponse, ExtensionInteractionResponse, ExtensionInteractionResponseResult, ExtensionOperationStatus, ExtensionActiveOperations, ExtensionRefreshResponse, ExtensionScopeRequest, ExtensionInstallRequest, ExtensionArchiveInstallRequest, ExtensionInstallResponse, ExtensionUpdateCheckResponse, GoalControlRequest, GoalSnapshotV2, GoalStateResponse, DaemonInitWorkspaceResult, DaemonMcpRestartResult, DaemonMcpManageAction, DaemonMcpManageResult, DaemonRuntimeMcpAddRequest, DaemonRuntimeMcpAddResult, DaemonRuntimeMcpRemoveResult, DaemonUpdateAgentRequest, DaemonWorkspaceAgentDetail, DaemonWorkspaceAgentsStatus, DaemonWorkspaceAcpPreheatResult, DaemonWorkspaceEnvStatus, DaemonWorkspaceExtensionsStatus, DaemonWorkspaceFile, DaemonWorkspaceFileBytes, DaemonWorkspaceFileEditRequest, DaemonWorkspaceFileEditResult, DaemonWorkspaceFileWriteRequest, DaemonWorkspaceFileWriteResult, DaemonWorkspaceMcpStatus, DaemonWorkspaceMcpConfigStatus, DaemonMcpConfigMutationResult, DaemonMcpConfigScope, DaemonWorkspaceRuntimeStatus, DaemonWorkspaceMcpInitializeResult, DaemonWorkspaceMcpReloadResult, DaemonWorkspaceMcpToolsStatus, DaemonWorkspaceMcpResourcesStatus, DaemonWorkspaceMemoryStatus, DaemonWorkspaceCapability, DaemonWorkspaceRemovalResult, DaemonWorkspaceUpdate, DaemonWorkspacePreflightStatus, DaemonWorkspaceProvidersStatus, DaemonWorkspaceSkillsStatus, DaemonSkillToggleResult, DaemonSkillInstallRequest, DaemonSkillMutationResult, DaemonSkillScope, DaemonWorkspaceToolsStatus, DaemonBrand, DaemonWorkspaceSettingsStatus, DaemonSettingUpdateResult, DaemonModelDeleteRequest, DaemonModelDeleteResult, DaemonSessionGroup, DaemonSessionGroupCatalog, DaemonSessionGroupInput, DaemonSessionGroupUpdate, DaemonSessionListPage, DaemonSessionListPageOptions, DaemonSessionOrganizationResult, DaemonSessionOrganizationUpdate, DaemonSessionSummary, DaemonSessionExportFormat, DaemonSessionExportResult, DaemonStatusReport, DaemonStatusReportDetail, DaemonUsageDashboard, DaemonUsageRange, DaemonWriteMemoryRequest, DaemonWriteMemoryResult, DaemonRevisionRequest } from '@qwen-code/sdk/daemon';
+export interface DaemonResourceOptions {
+    autoLoad?: boolean;
+    enabled?: boolean;
+}
+export interface ResourceState<T> {
+    data: T | undefined;
+    loading: boolean;
+    error: Error | undefined;
+}
+export interface ResourceResult<T> extends ResourceState<T> {
+    reload: () => Promise<T | undefined>;
+}
+export interface DaemonWorkspaceProviderProps {
+    baseUrl: string;
+    token?: string;
+    workspaceCwd?: string;
+    autoConnect?: boolean;
+    /**
+     * Optional pluggable transport forwarded to `DaemonClient`. When
+     * omitted the client uses the default REST+SSE transport.
+     */
+    transport?: import('@qwen-code/sdk/daemon').DaemonTransport;
+    children: ReactNode;
+}
+export type DaemonWorkspaceStatus = 'idle' | 'connecting' | 'connected' | 'error';
+export interface DaemonWorkspaceContextValue {
+    client: DaemonClient;
+    token?: string;
+    baseUrl: string;
+    workspaceCwd?: string;
+    status: DaemonWorkspaceStatus;
+    error?: Error;
+    capabilities?: DaemonCapabilities;
+    /**
+     * Web Shell branding resolved by the daemon from the operator settings scopes
+     * (system defaults, user, system). Fetched once per client instance beside
+     * capabilities; stays `undefined` while the fetch is in flight and on a
+     * daemon too old to have the route (whose 404 settles the fetch). A daemon
+     * that answered "no brand configured" resolves to an empty object `{}` —
+     * read that as "use the built-in brand", not as "still loading" (the SDK
+     * publishes the same contract). See
+     * {@link DaemonWorkspaceContextValue.brandSettled} to tell "no value yet"
+     * from "the definitive answer arrived" — consumers that clear cached
+     * branding must key on that flag rather than on `brand === undefined`, or
+     * they never fire on the most common deployment.
+     */
+    brand?: DaemonBrand;
+    /**
+     * True once this client's brand fetch has reached a definitive outcome:
+     * the daemon answered (with a brand or `{}`), or answered 404 (no route,
+     * so no brand will ever exist there). A retryable failure — a 503 while
+     * the runtime starts, a 429, a transport error — is unknown rather than
+     * absent and leaves this false, so cached chrome survives a blip.
+     * Per-client: resets to false when the client instance changes.
+     */
+    brandSettled?: boolean;
+    getCapabilities?: () => Promise<DaemonCapabilities>;
+    /**
+     * Force a fresh `/capabilities` fetch and push the result into the
+     * provider's `capabilities` state so consumers re-render. Unlike
+     * `getCapabilities` — which memoizes its first in-flight promise for the
+     * lifetime of the connection and never calls `setCapabilities` outside the
+     * initial mount — this bypasses that cache. Use it after a mutation that
+     * changes capabilities (e.g. registering a workspace) so the new state
+     * shows without a full page reload.
+     */
+    refreshCapabilities?: () => Promise<DaemonCapabilities>;
+    /**
+     * Re-issue the brand fetch for the current client, for the recovery path.
+     * A retryable failure (503, 429, transport) leaves the brand unsettled —
+     * without a re-ask, the in-app chrome renders built-in for the page's
+     * lifetime while the tab keeps the cached white-label. A no-op unless the
+     * brand is genuinely missing (`brand === undefined && !brandSettled`), so
+     * an already-resolved brand is never blanked mid-session and a definitive
+     * 404 outcome is not turned back into "loading". The same 404-only settle
+     * rule applies to the retry.
+     */
+    refreshBrand?: () => void;
+    actions: DaemonWorkspaceActions;
+}
+export interface DaemonFileStat {
+    kind: 'stat';
+    path: string;
+    type: 'file' | 'directory' | 'symlink' | 'other';
+    sizeBytes: number;
+    modifiedMs: number;
+}
+export interface DaemonDirectoryEntry {
+    name: string;
+    kind: 'file' | 'directory' | 'symlink' | 'other';
+    ignored: boolean;
+}
+export interface DaemonDirectoryListing {
+    kind: 'list';
+    path: string;
+    entries: DaemonDirectoryEntry[];
+    truncated: boolean;
+}
+export interface DaemonGlobOptions {
+    maxResults?: number;
+    includeIgnored?: boolean;
+    cwd?: string;
+}
+export interface DaemonGlobResult {
+    matches: string[];
+}
+export interface DaemonChannelsResource {
+    catalog: DaemonChannelTypeCatalog;
+    snapshot: DaemonChannelsSnapshot;
+}
+export interface DaemonChannelPairingActions {
+    list(name: string): Promise<DaemonChannelPairingRequestsSnapshot>;
+    approve(name: string, code: string): Promise<DaemonChannelPairingApprovalResult>;
+    approvals(name: string): Promise<DaemonChannelPairingApprovalsSnapshot>;
+    revoke(name: string, request: DaemonChannelPairingRevocationRequest): Promise<DaemonChannelPairingRevocationResult>;
+}
+/** A durable scheduled task as returned by the daemon. `name`/`enabled` are
+ * normalized (never undefined): `name: null` = unnamed, `enabled` defaults to
+ * true for tasks created before the field existed. */
+/** One recorded fire of a recurring scheduled task, newest last in
+ * {@link DaemonScheduledTask.runs}. Mirrors the daemon's wire shape. */
+export interface DaemonScheduledTaskRun {
+    /** Fire time (epoch ms). */
+    at: number;
+    /** `'scheduled'` (on-time), `'catch-up'` (fired late), or `'manual'` (user
+     * "run now"); absent = scheduled. */
+    kind?: 'scheduled' | 'catch-up' | 'manual';
+    /** The session the fire ran in, when present. Mirrors the daemon's
+     * `CronTaskRun.sessionId` so the UI can open the run conversation. */
+    sessionId?: string;
+    /** The daemon could not create the fresh session requested for this run. */
+    sessionDispatchFailed?: boolean;
+    /** READ-ONLY legacy compat: a pre-removal version stamped this on a fire whose
+     * precondition withheld the prompt. Never written now, but kept so the UI can
+     * still mark such stored entries "skipped" instead of showing them as ordinary
+     * successful runs. Absent = a real dispatched run. */
+    withheld?: boolean;
+}
+export interface DaemonScheduledTask {
+    id: string;
+    name: string | null;
+    cron: string;
+    prompt: string;
+    recurring: boolean;
+    enabled: boolean;
+    createdAt: number;
+    lastFiredAt: number | null;
+    /** Next scheduled fire (epoch ms), or null for a disabled task. A GET-time
+     * snapshot the UI counts down against; it advances on the next reload. */
+    nextRunAt: number | null;
+    /** Id of the dedicated session this task is bound to — its transcript is the
+     * task's run history. Null for unbound tool-created/legacy tasks. */
+    sessionId: string | null;
+    /** `persistent` reuses the task's bound session; `per_run` creates a fresh
+     * child session for every scheduled or manual fire. */
+    sessionMode?: 'persistent' | 'per_run';
+    /** Model service selected for each fresh per-run session. */
+    modelServiceId?: string | null;
+    /** Named group assigned to each fresh per-run session. */
+    groupId?: string | null;
+    /** Bounded, newest-last history of recent fires. Empty for tasks that have
+     * not fired (and, by nature, for one-shots — they are deleted on fire). */
+    runs: DaemonScheduledTaskRun[];
+    /** The registered workspace this task belongs to, when the aggregated
+     * multi-workspace view tagged it client-side. Absent (single-workspace) means
+     * the primary workspace. `workspaceId` targets its workspace-qualified route;
+     * `workspaceCwd` labels the card. The daemon never sends these — they are
+     * attached by the client after a per-workspace fetch. */
+    workspaceId?: string;
+    workspaceCwd?: string;
+}
+export interface DaemonCreateScheduledTaskRequest {
+    cron: string;
+    prompt: string;
+    /** Omit or null for an unnamed task. */
+    name?: string | null;
+    /** Defaults to true (fire on every match until deleted/expired). */
+    recurring?: boolean;
+    /** Defaults to true. */
+    enabled?: boolean;
+    /** Reuse an existing live, idle session instead of creating one. */
+    sessionId?: string | null;
+    /** Defaults to `persistent` when omitted. */
+    sessionMode?: 'persistent' | 'per_run';
+    /** Model service for fresh per-run sessions. */
+    modelServiceId?: string;
+    /** Named group for fresh per-run sessions. */
+    groupId?: string;
+}
+/** Partial update. `name: null` (or '') clears the name. Omitted fields are
+ * left unchanged. */
+export interface DaemonUpdateScheduledTaskRequest {
+    cron?: string;
+    prompt?: string;
+    name?: string | null;
+    recurring?: boolean;
+    enabled?: boolean;
+    sessionMode?: 'persistent' | 'per_run';
+    /** Null clears the selected model. */
+    modelServiceId?: string | null;
+    /** Null clears the selected group. */
+    groupId?: string | null;
+}
+export interface DaemonAddWorkspaceResult {
+    id: string;
+    cwd: string;
+    displayName?: string;
+    primary: boolean;
+    trusted: boolean;
+    persisted?: boolean;
+}
+/**
+ * One resident session's incomplete `/goal`, read from its persisted Goal
+ * runtime. Paused and blocked goals are included; unloaded sessions are not.
+ */
+export interface DaemonGoal {
+    /** The session driving this goal; its transcript is the goal's history. */
+    sessionId: string;
+    /** The session's label, or null — the UI falls back to the id. */
+    displayName: string | null;
+    condition: string;
+    /** Canonical Goal turns completed so far. */
+    iterations: number;
+    setAt: number;
+    /** Why the Goal last stopped, or the verifier's most recent reason. */
+    lastReason?: string;
+    /**
+     * The owning session is mid-turn. For a goal session that is almost always
+     * the loop working, but a manual prompt in the same session sets it too.
+     */
+    hasActivePrompt: boolean;
+    /** Canonical lifecycle state; UI controls must use its goalId/revision. */
+    snapshot: GoalSnapshotV2;
+}
+/** The `GET /goals` payload. */
+export interface DaemonGoalList {
+    goals: DaemonGoal[];
+    /**
+     * Sessions whose goal could not be probed (wedged or dying child). Their
+     * goals are missing from `goals`, so a non-zero count means this list is
+     * incomplete rather than empty.
+     */
+    droppedCount: number;
+}
+export interface DaemonWorkspacePathSuggestion {
+    name: string;
+    path: string;
+}
+export interface DaemonWorkspacePathSuggestions {
+    kind: 'workspace-path-suggestions';
+    /** Directory the suggestions were listed from. */
+    dir: string;
+    /** Path separator of the daemon host, for appending on accept. */
+    sep: string;
+    suggestions: DaemonWorkspacePathSuggestion[];
+    truncated: boolean;
+}
+export type DaemonWorkspaceDirectoryPickerResult = {
+    kind: 'workspace-directory-picker';
+    selected: true;
+    path: string;
+} | {
+    kind: 'workspace-directory-picker';
+    selected: false;
+};
+export interface DaemonWorkspaceActions {
+    listSessions(options?: DaemonSessionListPageOptions): Promise<DaemonSessionSummary[]>;
+    listSessionsPage(options?: DaemonSessionListPageOptions): Promise<DaemonSessionListPage>;
+    listSessionGroups(workspaceCwd?: string): Promise<DaemonSessionGroupCatalog>;
+    createSessionGroup(input: DaemonSessionGroupInput, workspaceCwd?: string): Promise<DaemonSessionGroup>;
+    updateSessionGroup(groupId: string, update: DaemonSessionGroupUpdate): Promise<DaemonSessionGroup>;
+    deleteSessionGroup(groupId: string): Promise<{
+        deleted: boolean;
+    }>;
+    updateSessionOrganization(sessionId: string, update: DaemonSessionOrganizationUpdate): Promise<DaemonSessionOrganizationResult>;
+    deleteSession(sessionId: string): Promise<boolean>;
+    deleteSessions(sessionIds: string[]): Promise<{
+        removed: string[];
+        notFound: string[];
+        errors: Array<{
+            sessionId: string;
+            error: string;
+        }>;
+    }>;
+    exportSession(sessionId: string, format?: DaemonSessionExportFormat): Promise<DaemonSessionExportResult>;
+    /**
+     * Move a session to the archived directory. Idempotent: an
+     * already-archived session resolves `true`. Rejects if the daemon
+     * reports a per-session error (e.g. an archive/unarchive conflict).
+     */
+    archiveSession(sessionId: string): Promise<boolean>;
+    /** Restore an archived session to the active directory. Idempotent. */
+    unarchiveSession(sessionId: string): Promise<boolean>;
+    loadChannels(): Promise<DaemonChannelsResource>;
+    upsertChannel(name: string, request: DaemonChannelUpsertRequest): Promise<DaemonChannelMutationResult>;
+    removeChannel(name: string, request: DaemonRevisionRequest): Promise<DaemonChannelMutationResult>;
+    setChannelStartup(name: string, request: DaemonChannelStartupRequest): Promise<DaemonChannelMutationResult>;
+    startChannel(name: string): Promise<DaemonChannelMutationResult>;
+    stopChannel(name: string): Promise<DaemonChannelMutationResult>;
+    restartChannel(name: string): Promise<DaemonChannelMutationResult>;
+    channelPairing: DaemonChannelPairingActions;
+    ensureRuntime(): Promise<DaemonWorkspaceRuntimeStatus>;
+    loadMcpConfig(): Promise<DaemonWorkspaceMcpConfigStatus>;
+    loadMcpStatus(): Promise<DaemonWorkspaceMcpStatus>;
+    initializeMcp(): Promise<DaemonWorkspaceMcpInitializeResult>;
+    reloadMcp(): Promise<DaemonWorkspaceMcpReloadResult>;
+    loadMcpTools(serverName: string): Promise<DaemonWorkspaceMcpToolsStatus>;
+    loadMcpResources(serverName: string): Promise<DaemonWorkspaceMcpResourcesStatus>;
+    restartMcpServer(serverName: string): Promise<DaemonMcpRestartResult>;
+    manageMcpServer(serverName: string, action: DaemonMcpManageAction): Promise<DaemonMcpManageResult>;
+    addRuntimeMcpServer(request: DaemonRuntimeMcpAddRequest): Promise<DaemonRuntimeMcpAddResult>;
+    removeRuntimeMcpServer(name: string): Promise<DaemonRuntimeMcpRemoveResult>;
+    setMcpServer(name: string, scope: DaemonMcpConfigScope, config: Record<string, unknown>): Promise<DaemonMcpConfigMutationResult>;
+    removeMcpServer(name: string, scope: DaemonMcpConfigScope): Promise<DaemonMcpConfigMutationResult>;
+    setMcpServerEnabled(name: string, scope: DaemonMcpConfigScope, enabled: boolean): Promise<DaemonMcpConfigMutationResult>;
+    loadDaemonStatus(detail?: DaemonStatusReportDetail): Promise<DaemonStatusReport>;
+    loadUsageDashboard(opts?: {
+        range?: DaemonUsageRange;
+        heatmapDays?: number;
+    }): Promise<DaemonUsageDashboard>;
+    loadSkillsStatus(): Promise<DaemonWorkspaceSkillsStatus>;
+    setWorkspaceSkillEnabled(skillName: string, enabled: boolean): Promise<DaemonSkillToggleResult>;
+    installWorkspaceSkill(request: DaemonSkillInstallRequest): Promise<DaemonSkillMutationResult>;
+    deleteWorkspaceSkill(skillName: string, scope: DaemonSkillScope): Promise<DaemonSkillMutationResult>;
+    loadExtensionsStatus(): Promise<DaemonWorkspaceExtensionsStatus>;
+    preheatAcp(timeoutMs?: number): Promise<DaemonWorkspaceAcpPreheatResult>;
+    loadToolsStatus(): Promise<DaemonWorkspaceToolsStatus>;
+    setWorkspaceToolEnabled(toolName: string, enabled: boolean): Promise<unknown>;
+    loadSettingsStatus(): Promise<DaemonWorkspaceSettingsStatus>;
+    setWorkspaceSetting(scope: 'workspace' | 'user', key: string, value: unknown, options?: {
+        mcpServerMutation?: {
+            operation: 'set' | 'remove';
+            name: string;
+        };
+    }): Promise<DaemonSettingUpdateResult>;
+    loadMemoryStatus(): Promise<DaemonWorkspaceMemoryStatus>;
+    readWorkspaceFile(filePath: string): Promise<DaemonWorkspaceFile>;
+    writeMemory(req: DaemonWriteMemoryRequest): Promise<DaemonWriteMemoryResult>;
+    generateContent(prompt: string, opts?: {
+        signal?: AbortSignal;
+    }): AsyncGenerator<DaemonWorkspaceGenerationEvent>;
+    listAgents(): Promise<DaemonWorkspaceAgentsStatus>;
+    getAgent(agentType: string, scope?: 'workspace' | 'global'): Promise<DaemonWorkspaceAgentDetail>;
+    createAgent(req: DaemonCreateAgentRequest): Promise<DaemonAgentMutationResult>;
+    generateAgent(description: string): Promise<DaemonGeneratedAgentContent>;
+    deleteAgent(agentType: string, scope?: 'workspace' | 'global'): Promise<void>;
+    globWorkspace(pattern: string, opts?: DaemonGlobOptions): Promise<DaemonGlobResult>;
+    readFileBytes(filePath: string, opts?: {
+        offset?: number;
+        maxBytes?: number;
+    }): Promise<DaemonWorkspaceFileBytes>;
+    writeFile(req: DaemonWorkspaceFileWriteRequest): Promise<DaemonWorkspaceFileWriteResult>;
+    editFile(req: DaemonWorkspaceFileEditRequest): Promise<DaemonWorkspaceFileEditResult>;
+    stat(filePath: string): Promise<DaemonFileStat>;
+    listDirectory(dirPath: string): Promise<DaemonDirectoryListing>;
+    listScheduledTasks(workspaceId?: string): Promise<DaemonScheduledTask[]>;
+    createScheduledTask(req: DaemonCreateScheduledTaskRequest, workspaceId?: string): Promise<DaemonScheduledTask>;
+    updateScheduledTask(id: string, patch: DaemonUpdateScheduledTaskRequest, workspaceId?: string): Promise<DaemonScheduledTask>;
+    /** Run now. Persistent tasks are only recorded here and are executed by the
+     * caller; per-run tasks are dispatched into a fresh daemon session. */
+    runScheduledTask(id: string, workspaceId?: string): Promise<DaemonScheduledTask>;
+    deleteScheduledTask(id: string, workspaceId?: string): Promise<void>;
+    listGoals(): Promise<DaemonGoalList>;
+    controlGoal(sessionId: string, request: GoalControlRequest): Promise<GoalStateResponse>;
+    /** Drop a session's goal hook. No-op when that session has no active goal. */
+    clearGoal(sessionId: string): Promise<{
+        cleared: boolean;
+    }>;
+    loadProviders(workspaceCwd?: string): Promise<DaemonWorkspaceProvidersStatus>;
+    loadEnv(): Promise<DaemonWorkspaceEnvStatus>;
+    loadPreflight(): Promise<DaemonWorkspacePreflightStatus>;
+    initWorkspace(opts?: {
+        force?: boolean;
+    }): Promise<DaemonInitWorkspaceResult>;
+    updateAgent(agentType: string, req: DaemonUpdateAgentRequest, scope?: 'workspace' | 'global'): Promise<DaemonAgentMutationResult>;
+    installExtension(params: ExtensionInstallRequest, clientId?: string): Promise<ExtensionInstallResponse>;
+    installExtensionArchive(params: ExtensionArchiveInstallRequest, clientId?: string): Promise<ExtensionInstallResponse>;
+    extensionOperationStatus(operationId: string): Promise<ExtensionOperationStatus>;
+    activeExtensionOperations(): Promise<ExtensionActiveOperations>;
+    respondToExtensionInteraction(operationId: string, interactionId: string, response: ExtensionInteractionResponse, clientId?: string): Promise<ExtensionInteractionResponseResult>;
+    checkExtensionUpdates(clientId?: string): Promise<ExtensionUpdateCheckResponse>;
+    refreshExtensions(clientId?: string): Promise<ExtensionRefreshResponse>;
+    enableExtension(name: string, params: ExtensionScopeRequest, clientId?: string): Promise<ExtensionMutationResponse>;
+    disableExtension(name: string, params: ExtensionScopeRequest, clientId?: string): Promise<ExtensionMutationResponse>;
+    updateExtension(name: string, clientId?: string): Promise<ExtensionMutationResponse>;
+    uninstallExtension(name: string, clientId?: string): Promise<ExtensionMutationResponse>;
+    startDeviceFlow(providerId: DaemonAuthProviderId): Promise<DaemonDeviceFlowStartResult>;
+    getDeviceFlow(deviceFlowId: string, opts?: {
+        signal?: AbortSignal;
+    }): Promise<DaemonDeviceFlowState>;
+    cancelDeviceFlow(deviceFlowId: string): Promise<void>;
+    getAuthStatus(): Promise<DaemonAuthStatusSnapshot>;
+    getAuthProviders(): Promise<DaemonAuthProviderCatalog>;
+    installAuthProvider(req: DaemonAuthProviderInstallRequest): Promise<DaemonAuthProviderInstallResult>;
+    deleteModel(target: DaemonModelDeleteRequest): Promise<DaemonModelDeleteResult>;
+    addWorkspace(cwd: string, options?: {
+        persist?: boolean;
+        displayName?: string;
+    }): Promise<DaemonAddWorkspaceResult>;
+    addScratchWorkspace(): Promise<DaemonAddWorkspaceResult>;
+    suggestWorkspacePaths(prefix: string): Promise<DaemonWorkspacePathSuggestions>;
+    pickWorkspaceDirectory(): Promise<DaemonWorkspaceDirectoryPickerResult>;
+    updateWorkspace(workspaceSelector: string, update: DaemonWorkspaceUpdate): Promise<DaemonWorkspaceCapability>;
+    removeWorkspace(workspaceId: string, options?: {
+        force?: boolean;
+        timeoutMs?: number;
+    }): Promise<DaemonWorkspaceRemovalResult>;
+}