@otto-code/client 0.8.12 → 0.8.14

package/dist/index.d.ts

@@ -1,6 +1,6 @@
-import type { AgentSnapshotPayload, CreateAgentRequestMessage, FetchWorkspacesRequestMessage, FetchWorkspacesResponseMessage, GetProvidersSnapshotResponseMessage, ListAvailableProvidersResponse, ListProviderFeaturesRequestMessage, ListProviderFeaturesResponseMessage, ListProviderModelsResponseMessage, ListProviderModesResponseMessage, MutableDaemonConfig, MutableDaemonConfigPatch, ProviderDiagnosticResponseMessage, ProjectPlacementPayload, RefreshProvidersSnapshotResponseMessage, SendAgentMessageRequest, SessionOutboundMessage, WorkspaceDescriptorPayload } from "@otto-code/protocol/messages";
+import type { AgentSnapshotPayload, CreateAgentRequestMessage, FetchWorkspacesRequestMessage, FetchWorkspacesResponseMessage, GetProvidersSnapshotResponseMessage, ListAvailableProvidersResponse, ListProviderFeaturesRequestMessage, ListProviderFeaturesResponseMessage, ListProviderModelsResponseMessage, ListProviderModesResponseMessage, MutableDaemonConfig, MutableDaemonConfigPatch, ProviderDiagnosticResponseMessage, ProjectPlacementPayload, RefreshProvidersSnapshotResponseMessage, SendAgentMessageRequest, SessionOutboundMessage, WorkspaceDescriptorPayload, WorkspaceCreateRequest } from "@otto-code/protocol/messages";
 import { DaemonClient } from "./daemon-client.js";
-import type { FetchAgentTimelineCursor, FetchAgentTimelineDirection, FetchAgentTimelinePayload, FetchAgentTimelineProjection } from "./daemon-client.js";
+import type { FetchAgentsEntry, FetchAgentsOptions, FetchAgentsPageInfo, FetchAgentTimelineCursor, FetchAgentTimelineDirection, FetchAgentTimelinePayload, FetchAgentTimelineProjection, WaitForFinishResult } from "./daemon-client.js";
 export { DaemonClient };
 export type { DaemonClientConfig, DaemonEvent, BrowserAutomationExecuteRequestMessage, BrowserAutomationExecuteResponseMessage, CodeRenameApplyOutcome, CodeRenameApplyQuery, CodeRenamePlan, CodeRenameUndoOutcome, HostingAuthStatusPayload, HostingListOwnersPayload, HostingListRepositoriesPayload, HostingSearchPayload, ProjectScaffoldPayload, WebSocketFactory, WebSocketLike, } from "./daemon-client.js";
 export type ConnectionState = {
@@ -46,6 +46,13 @@ export interface OttoClientConfig {
 }
 export type OttoWorkspace = WorkspaceDescriptorPayload;
 export type OttoAgent = AgentSnapshotPayload;
+export type OttoAgentListOptions = FetchAgentsOptions;
+export interface OttoAgentListResult {
+    requestId: string;
+    subscriptionId?: string | null;
+    entries: FetchAgentsEntry[];
+    pageInfo: FetchAgentsPageInfo;
+}
 export type OttoWorkspaceListOptions = Omit<FetchWorkspacesRequestMessage, "type" | "requestId"> & {
     requestId?: string;
 };
@@ -59,11 +66,9 @@ export interface OttoWorkspaceOpenOptions {
     cwd: string;
     requestId?: string;
 }
-export interface OttoWorkspaceOpenResult {
-    requestId: string;
-    workspace: OttoWorkspaceHandle | null;
-    error: string | null;
-}
+export type OttoWorkspaceCreateOptions = Omit<WorkspaceCreateRequest, "type" | "requestId"> & {
+    requestId?: string;
+};
 export interface OttoWorkspaceArchiveResult {
     requestId: string;
     workspaceId: string;
@@ -74,19 +79,17 @@ export type OttoWorkspaceUpdate = Extract<SessionOutboundMessage, {
     type: "workspace_update";
 }>["payload"];
 export type OttoWorkspaceUpdateHandler = (update: OttoWorkspaceUpdate) => void;
-/**
- * A handle is a stable typed reference to a daemon resource. Its identity is the
- * daemon id, and `latest()` only returns the most recent snapshot this handle has
- * seen through construction, `refetch()`, or this handle's local subscription.
- */
 export interface OttoWorkspaceHandle {
     readonly id: string;
-    latest(): OttoWorkspace | null;
-    /**
-     * Fetches a fresh workspace snapshot through the existing workspace list RPC,
-     * exact-matches this handle id from the result, and updates `latest()`.
-     */
-    refetch(options?: {
+    readonly projectId: string | null;
+    readonly directory: string | null;
+    readonly name: string | null;
+    readonly status: OttoWorkspace["status"] | null;
+    readonly agents: {
+        create(options: OttoWorkspaceAgentCreateOptions): Promise<OttoAgentHandle>;
+    };
+    current(): OttoWorkspace | null;
+    refresh(options?: {
         requestId?: string;
     }): Promise<OttoWorkspace | null>;
     archive(requestId?: string): Promise<OttoWorkspaceArchiveResult>;
@@ -101,8 +104,8 @@ export interface OttoWorkspaceHandle {
 export interface OttoWorkspaceActions {
     list(options?: OttoWorkspaceListOptions): Promise<OttoWorkspaceListResult>;
     ref(workspace: string | OttoWorkspace): OttoWorkspaceHandle;
-    open(input: string | OttoWorkspaceOpenOptions, requestId?: string): Promise<OttoWorkspaceOpenResult>;
-    create(input: string | OttoWorkspaceOpenOptions, requestId?: string): Promise<OttoWorkspaceOpenResult>;
+    open(input: string | OttoWorkspaceOpenOptions, requestId?: string): Promise<OttoWorkspaceHandle>;
+    create(options: OttoWorkspaceCreateOptions): Promise<OttoWorkspaceHandle>;
     archive(workspace: string | OttoWorkspaceHandle, requestId?: string): Promise<OttoWorkspaceArchiveResult>;
     /**
      * Local event subscription over the low-level driver's workspace_update stream.
@@ -111,23 +114,38 @@ export interface OttoWorkspaceActions {
     subscribe(handler: OttoWorkspaceUpdateHandler): () => void;
 }
 type OttoAgentSessionConfig = CreateAgentRequestMessage["config"];
-type OttoAgentProvider = OttoAgentSessionConfig["provider"];
-type OttoAgentConfigOverrides = Partial<Omit<OttoAgentSessionConfig, "provider" | "cwd">>;
-export interface OttoAgentCreateOptions extends OttoAgentConfigOverrides {
-    config?: OttoAgentSessionConfig;
-    provider?: CreateAgentRequestMessage["config"]["provider"];
-    cwd?: string;
-    workspaceId?: string;
-    callerAgentId?: string;
-    initialPrompt?: string;
+export type OttoAgentProvider = OttoAgentSessionConfig["provider"];
+export type OttoProviderFeatureValues = Record<string, unknown>;
+export interface OttoAgentConfig {
+    /** Provider and model in `provider/model` format. */
+    provider: string;
+    modeId?: OttoAgentSessionConfig["modeId"];
+    thinkingOptionId?: OttoAgentSessionConfig["thinkingOptionId"];
+    featureValues?: OttoProviderFeatureValues;
+    /** JSON-safe provider-native settings, validated by the selected provider. */
+    options?: OttoAgentSessionConfig["providerOptions"];
+    systemPrompt?: OttoAgentSessionConfig["systemPrompt"];
+    toolPolicy?: OttoAgentSessionConfig["toolPolicy"];
+    mcpServers?: OttoAgentSessionConfig["mcpServers"];
+}
+export interface OttoAgentCreateOptions {
+    config: OttoAgentConfig;
+    cwd: string;
+    parent?: string | OttoAgentHandle;
+    title?: OttoAgentSessionConfig["title"];
+    env?: CreateAgentRequestMessage["env"];
+    prompt?: string;
     clientMessageId?: string;
     outputSchema?: Record<string, unknown>;
     images?: CreateAgentRequestMessage["images"];
     attachments?: CreateAgentRequestMessage["attachments"];
     git?: CreateAgentRequestMessage["git"];
+    worktree?: CreateAgentRequestMessage["worktree"];
+    autoArchive?: CreateAgentRequestMessage["autoArchive"];
     requestId?: string;
     labels?: Record<string, string>;
 }
+export type OttoWorkspaceAgentCreateOptions = Omit<OttoAgentCreateOptions, "cwd">;
 export interface OttoAgentRefetchResult {
     agent: OttoAgent;
     project: ProjectPlacementPayload | null;
@@ -147,6 +165,10 @@ export interface OttoAgentSendOptions {
     }>;
     attachments?: SendAgentMessageRequest["attachments"];
 }
+export interface OttoAgentRunOptions extends OttoAgentSendOptions {
+    timeoutMs?: number;
+}
+export type OttoAgentRunResult = WaitForFinishResult;
 export type OttoAgentUpdate = Extract<SessionOutboundMessage, {
     type: "agent_update";
 }>["payload"];
@@ -157,8 +179,8 @@ export type OttoAgentUpdateHandler = (update: OttoAgentUpdate) => void;
 export interface OttoAgentTimelineHandle {
     /**
      * Fetches a fresh timeline page through the existing daemon RPC. If the daemon
-     * includes an agent snapshot in the response, the parent handle's `latest()`
-     * is updated to that snapshot.
+     * includes an agent snapshot in the response, the parent handle is updated to
+     * that value.
      */
     refetch(options?: OttoAgentTimelineRefetchOptions): Promise<FetchAgentTimelinePayload>;
     /**
@@ -167,18 +189,19 @@ export interface OttoAgentTimelineHandle {
      */
     subscribe(handler: (event: OttoAgentStream) => void): () => void;
 }
-/**
- * Agent handles follow the same identity/snapshot rule as workspace handles:
- * `id` is stable, while `latest()` is only the newest snapshot observed by this
- * handle through construction, `refetch()`, timeline refetch, archive, or local
- * agent_update subscription.
- */
 export interface OttoAgentHandle {
     readonly id: string;
+    readonly workspaceId: string | null;
+    readonly cwd: string | null;
+    readonly status: OttoAgent["status"] | null;
     readonly timeline: OttoAgentTimelineHandle;
-    latest(): OttoAgent | null;
-    refetch(requestId?: string): Promise<OttoAgentRefetchResult | null>;
+    current(): OttoAgent | null;
+    refresh(requestId?: string): Promise<OttoAgentRefetchResult | null>;
     send(text: string, options?: OttoAgentSendOptions): Promise<void>;
+    /** Sends a prompt and resolves when that turn finishes or needs attention. */
+    run(text: string, options?: OttoAgentRunOptions): Promise<OttoAgentRunResult>;
+    /** Waits for the current turn, including one started with `prompt`. */
+    waitForFinish(timeoutMs?: number): Promise<OttoAgentRunResult>;
     archive(): Promise<{
         archivedAt: string;
     }>;
@@ -186,6 +209,7 @@ export interface OttoAgentHandle {
     subscribe(handler: (update: OttoAgentUpdate) => void): () => void;
 }
 export interface OttoAgentActions {
+    list(options?: OttoAgentListOptions): Promise<OttoAgentListResult>;
     ref(agent: string | OttoAgent): OttoAgentHandle;
     create(options: OttoAgentCreateOptions): Promise<OttoAgentHandle>;
     /**
@@ -194,19 +218,13 @@ export interface OttoAgentActions {
      */
     subscribe(handler: OttoAgentUpdateHandler): () => void;
 }
-export interface OttoProviderConfig extends OttoProviderConfigInput {
-    provider: OttoAgentProvider;
-}
-export type OttoProviderFeatureValues = Record<string, unknown>;
-export interface OttoProviderConfigInput {
-    model?: string;
-    modeId?: string;
-    thinkingOptionId?: string;
-    featureValues?: OttoProviderFeatureValues;
-}
 export type OttoProviderModelsResult = ListProviderModelsResponseMessage["payload"];
 export type OttoProviderModesResult = ListProviderModesResponseMessage["payload"];
-export type OttoProviderFeaturesInput = ListProviderFeaturesRequestMessage["draftConfig"];
+type OttoProviderFeaturesDraft = ListProviderFeaturesRequestMessage["draftConfig"];
+export interface OttoProviderFeaturesInput extends Omit<OttoProviderFeaturesDraft, "provider" | "model"> {
+    /** Provider and model in `provider/model` format. */
+    provider: string;
+}
 export type OttoProviderFeaturesResult = ListProviderFeaturesResponseMessage["payload"];
 export type OttoProviderAvailabilityResult = ListAvailableProvidersResponse["payload"];
 export type OttoProviderSnapshotResult = GetProvidersSnapshotResponseMessage["payload"];
@@ -224,12 +242,10 @@ export interface OttoProviderRefreshOptions {
     providers?: OttoAgentProvider[];
     requestId?: string;
 }
+export interface OttoProviderWaitOptions extends OttoProviderListOptions {
+    timeoutMs?: number;
+}
 export interface OttoProviderActions {
-    codex(input?: OttoProviderConfigInput): OttoProviderConfig;
-    claude(input?: OttoProviderConfigInput): OttoProviderConfig;
-    opencode(input?: OttoProviderConfigInput): OttoProviderConfig;
-    copilot(input?: OttoProviderConfigInput): OttoProviderConfig;
-    config(provider: OttoAgentProvider, input?: OttoProviderConfigInput): OttoProviderConfig;
     listModels(provider: OttoAgentProvider, options?: OttoProviderListOptions): Promise<OttoProviderModelsResult>;
     listModes(provider: OttoAgentProvider, options?: OttoProviderListOptions): Promise<OttoProviderModesResult>;
     listFeatures(draftConfig: OttoProviderFeaturesInput, options?: {
@@ -239,6 +255,8 @@ export interface OttoProviderActions {
         requestId?: string;
     }): Promise<OttoProviderAvailabilityResult>;
     snapshot(options?: OttoProviderListOptions): Promise<OttoProviderSnapshotResult>;
+    /** Resolves after the daemon's lazy provider discovery has finished. */
+    waitForReady(options?: OttoProviderWaitOptions): Promise<OttoProviderSnapshotResult>;
     refresh(options?: OttoProviderRefreshOptions): Promise<OttoProviderRefreshResult>;
     diagnostic(provider: OttoAgentProvider, options?: {
         requestId?: string;

package/dist/index.js

@@ -1,45 +1,74 @@
 import { DaemonClient } from "./daemon-client.js";
 export { DaemonClient };
+/**
+ * Coding turns routinely run for minutes, so the handle waits far longer than
+ * the transport's own conservative default.
+ */
+const DEFAULT_WAIT_FOR_FINISH_MS = 10 * 60000;
 export function createOttoClient(config) {
     const daemonClient = new DaemonClient({
         ...config,
         clientId: config.clientId ?? createGeneratedClientId(),
         clientType: "cli",
     });
-    const createWorkspaceHandle = createWorkspaceHandleFactory(daemonClient);
     const createAgentHandle = createAgentHandleFactory(daemonClient);
+    const createAgent = async (options, placement) => {
+        const { config: agentConfig, cwd, parent, title, prompt, ...requestOptions } = options;
+        const { provider: providerModel, options: providerOptions, ...runtimeConfig } = agentConfig;
+        const { provider, model } = parseProviderModel(providerModel);
+        const effectiveCwd = placement?.cwd ?? cwd;
+        const agent = await daemonClient.createAgent({
+            ...requestOptions,
+            config: {
+                ...runtimeConfig,
+                provider,
+                model,
+                cwd: effectiveCwd,
+                ...(title !== undefined ? { title } : {}),
+                ...(providerOptions !== undefined ? { providerOptions } : {}),
+            },
+            ...(placement ? { workspaceId: placement.workspaceId } : {}),
+            ...(parent ? { callerAgentId: resolveAgentId(parent) } : {}),
+            ...(prompt !== undefined ? { initialPrompt: prompt } : {}),
+        });
+        return createAgentHandle(agent);
+    };
+    const createWorkspaceHandle = createWorkspaceHandleFactory(daemonClient, createAgent);
     return {
         workspaces: {
             list: (options) => daemonClient.fetchWorkspaces(options),
             ref: (workspace) => createWorkspaceHandle(workspace),
             open: (input, requestId) => openWorkspace(daemonClient, createWorkspaceHandle, input, requestId),
-            create: (input, requestId) => openWorkspace(daemonClient, createWorkspaceHandle, input, requestId),
+            create: async ({ requestId, ...options }) => {
+                const result = await daemonClient.createWorkspace(options, requestId);
+                if (result.error || !result.workspace) {
+                    throw new Error(result.error ?? "The daemon did not create a workspace");
+                }
+                return createWorkspaceHandle(result.workspace);
+            },
             archive: (workspace, requestId) => daemonClient.archiveWorkspace(resolveWorkspaceId(workspace), { requestId }),
             subscribe: (handler) => daemonClient.on("workspace_update", (message) => {
                 handler(message.payload);
             }),
         },
         agents: {
+            list: (options) => daemonClient.fetchAgents(options),
             ref: (agent) => createAgentHandle(agent),
-            create: async (options) => {
-                const agent = await daemonClient.createAgent(options);
-                return createAgentHandle(agent);
-            },
+            create: (options) => createAgent(options),
             subscribe: (handler) => daemonClient.on("agent_update", (message) => {
                 handler(message.payload);
             }),
         },
         providers: {
-            codex: (input) => providerConfig("codex", input),
-            claude: (input) => providerConfig("claude", input),
-            opencode: (input) => providerConfig("opencode", input),
-            copilot: (input) => providerConfig("copilot", input),
-            config: (provider, input) => providerConfig(provider, input),
             listModels: (provider, options) => daemonClient.listProviderModels(provider, options),
             listModes: (provider, options) => daemonClient.listProviderModes(provider, options),
-            listFeatures: (draftConfig, options) => daemonClient.listProviderFeatures(draftConfig, options),
+            listFeatures: ({ provider: providerModel, ...draftConfig }, options) => {
+                const { provider, model } = parseProviderModel(providerModel);
+                return daemonClient.listProviderFeatures({ ...draftConfig, provider, model }, options);
+            },
             listAvailable: (options) => daemonClient.listAvailableProviders(options),
             snapshot: (options) => daemonClient.getProvidersSnapshot(options),
+            waitForReady: (options) => waitForProvidersReady(daemonClient, options),
             refresh: (options) => daemonClient.refreshProvidersSnapshot(options),
             diagnostic: (provider, options) => daemonClient.getProviderDiagnostic(provider, options),
             subscribe: (handler) => daemonClient.on("providers_snapshot_update", (message) => {
@@ -56,39 +85,69 @@ export function createOttoClient(config) {
         getConnectionState: () => daemonClient.getConnectionState(),
     };
 }
-function createWorkspaceHandleFactory(daemonClient) {
+function createWorkspaceHandleFactory(daemonClient, createAgent) {
     return (workspace) => {
         const id = typeof workspace === "string" ? workspace : workspace.id;
-        let latest = typeof workspace === "string" ? null : workspace;
-        return {
-            id,
-            latest: () => latest,
-            refetch: async (options) => {
-                // Best-effort: fetches one page and matches by id client-side, so a workspace beyond
-                // the first page won't be found. TODO: add a "get workspace by id" lookup and resolve
-                // by exact id instead of paging.
+        let current = typeof workspace === "string" ? null : workspace;
+        const refresh = async (options) => {
+            let cursor;
+            let requestId = options?.requestId;
+            do {
                 const result = await daemonClient.fetchWorkspaces({
-                    requestId: options?.requestId,
-                    page: { limit: 25 },
+                    requestId,
+                    page: { limit: 200, ...(cursor ? { cursor } : {}) },
                 });
-                latest = result.entries.find((entry) => entry.id === id) ?? null;
-                return latest;
+                const match = result.entries.find((entry) => entry.id === id);
+                if (match) {
+                    current = match;
+                    return current;
+                }
+                cursor = result.pageInfo.nextCursor ?? undefined;
+                requestId = undefined;
+            } while (cursor);
+            current = null;
+            return current;
+        };
+        return {
+            id,
+            get projectId() {
+                return current?.projectId ?? null;
+            },
+            get directory() {
+                return current?.workspaceDirectory ?? null;
+            },
+            get name() {
+                return current?.name ?? null;
+            },
+            get status() {
+                return current?.status ?? null;
+            },
+            agents: {
+                create: async (options) => {
+                    const snapshot = current ?? (await refresh());
+                    if (!snapshot?.workspaceDirectory) {
+                        throw new Error(`Workspace ${id} has no available directory`);
+                    }
+                    return createAgent({ ...options, cwd: snapshot.workspaceDirectory }, { workspaceId: id, cwd: snapshot.workspaceDirectory });
+                },
             },
+            current: () => current,
+            refresh,
             archive: async (requestId) => {
                 const result = await daemonClient.archiveWorkspace(id, { requestId });
-                if (latest) {
-                    latest = { ...latest, archivingAt: result.archivedAt };
+                if (current) {
+                    current = { ...current, archivingAt: result.archivedAt };
                 }
                 return result;
             },
             subscribe: (handler) => daemonClient.on("workspace_update", (message) => {
                 const update = message.payload;
                 if (update.kind === "upsert" && update.workspace.id === id) {
-                    latest = update.workspace;
+                    current = update.workspace;
                     handler(update);
                 }
                 if (update.kind === "remove" && update.id === id) {
-                    latest = null;
+                    current = null;
                     handler(update);
                 }
             }),
@@ -98,14 +157,14 @@ function createWorkspaceHandleFactory(daemonClient) {
 function createAgentHandleFactory(daemonClient) {
     return (agent) => {
         const id = typeof agent === "string" ? agent : agent.id;
-        let latest = typeof agent === "string" ? null : agent;
+        let current = typeof agent === "string" ? null : agent;
         const handle = {
             id,
             timeline: {
                 refetch: async (options) => {
                     const result = await daemonClient.fetchAgentTimeline(id, options);
                     if (result.agent) {
-                        latest = result.agent;
+                        current = result.agent;
                     }
                     return result;
                 },
@@ -115,10 +174,35 @@ function createAgentHandleFactory(daemonClient) {
                     }
                 }),
             },
-            latest: () => latest,
-            refetch: async (requestId) => {
+            get workspaceId() {
+                return current?.workspaceId ?? null;
+            },
+            get cwd() {
+                return current?.cwd ?? null;
+            },
+            get status() {
+                return current?.status ?? null;
+            },
+            current: () => current,
+            refresh: async (requestId) => {
                 const result = await daemonClient.fetchAgent({ agentId: id, requestId });
-                latest = result?.agent ?? null;
+                current = result?.agent ?? null;
+                return result;
+            },
+            run: async (text, options) => {
+                const { timeoutMs, ...sendOptions } = options ?? {};
+                await daemonClient.sendAgentMessage(id, text, sendOptions);
+                const result = await daemonClient.waitForFinish(id, timeoutMs ?? DEFAULT_WAIT_FOR_FINISH_MS);
+                if (result.final) {
+                    current = result.final;
+                }
+                return result;
+            },
+            waitForFinish: async (timeoutMs) => {
+                const result = await daemonClient.waitForFinish(id, timeoutMs ?? DEFAULT_WAIT_FOR_FINISH_MS);
+                if (result.final) {
+                    current = result.final;
+                }
                 return result;
             },
             send: async (text, options) => {
@@ -126,8 +210,8 @@ function createAgentHandleFactory(daemonClient) {
             },
             archive: async () => {
                 const result = await daemonClient.archiveAgent(id);
-                if (latest) {
-                    latest = { ...latest, archivedAt: result.archivedAt };
+                if (current) {
+                    current = { ...current, archivedAt: result.archivedAt };
                 }
                 return result;
             },
@@ -137,11 +221,11 @@ function createAgentHandleFactory(daemonClient) {
             subscribe: (handler) => daemonClient.on("agent_update", (message) => {
                 const update = message.payload;
                 if (update.kind === "upsert" && update.agent.id === id) {
-                    latest = update.agent;
+                    current = update.agent;
                     handler(update);
                 }
                 if (update.kind === "remove" && update.agentId === id) {
-                    latest = null;
+                    current = null;
                     handler(update);
                 }
             }),
@@ -152,23 +236,99 @@ function createAgentHandleFactory(daemonClient) {
 async function openWorkspace(daemonClient, createWorkspaceHandle, input, requestId) {
     const options = typeof input === "string" ? { cwd: input, requestId } : input;
     const result = await daemonClient.openProject(options.cwd, options.requestId);
-    return {
-        ...result,
-        workspace: result.workspace ? createWorkspaceHandle(result.workspace) : null,
-    };
+    if (result.error || !result.workspace) {
+        throw new Error(result.error ?? `The daemon did not open a workspace for ${options.cwd}`);
+    }
+    return createWorkspaceHandle(result.workspace);
 }
 function resolveWorkspaceId(workspace) {
     return typeof workspace === "string" ? workspace : workspace.id;
 }
-function providerConfig(provider, input = {}) {
+function resolveAgentId(agent) {
+    return typeof agent === "string" ? agent : agent.id;
+}
+function parseProviderModel(selection) {
+    const separator = selection.indexOf("/");
+    if (separator <= 0 || separator === selection.length - 1) {
+        throw new Error('Expected config.provider in "provider/model" format');
+    }
     return {
-        provider,
-        ...(input.model !== undefined ? { model: input.model } : {}),
-        ...(input.modeId !== undefined ? { modeId: input.modeId } : {}),
-        ...(input.thinkingOptionId !== undefined ? { thinkingOptionId: input.thinkingOptionId } : {}),
-        ...(input.featureValues !== undefined ? { featureValues: input.featureValues } : {}),
+        provider: selection.slice(0, separator),
+        model: selection.slice(separator + 1),
     };
 }
+function waitForProvidersReady(daemonClient, options = {}) {
+    // COMPAT(providersSnapshotCwd): added in v0.3.2, remove gate after 2027-02-10.
+    if (daemonClient.getLastServerInfoMessage()?.features?.providersSnapshotCwd !== true) {
+        return Promise.reject(new Error("Update the host to wait for provider discovery."));
+    }
+    const { timeoutMs = 60000, ...snapshotOptions } = options;
+    return new Promise((resolve, reject) => {
+        let settled = false;
+        let requestId = null;
+        let snapshotCwd;
+        const pendingUpdates = new Map();
+        let latestEntries = [];
+        const cleanup = () => {
+            clearTimeout(timeout);
+            unsubscribe();
+        };
+        const finish = (snapshot) => {
+            if (settled)
+                return;
+            settled = true;
+            cleanup();
+            resolve(snapshot);
+        };
+        const fail = (error) => {
+            if (settled)
+                return;
+            settled = true;
+            cleanup();
+            reject(error instanceof Error ? error : new Error(String(error)));
+        };
+        const updateMatches = (update) => update.cwd === snapshotCwd;
+        const unsubscribe = daemonClient.on("providers_snapshot_update", (message) => {
+            const update = message.payload;
+            if (!requestId) {
+                pendingUpdates.set(update.cwd, update);
+                return;
+            }
+            if (!updateMatches(update))
+                return;
+            latestEntries = update.entries;
+            if (update.entries.some((entry) => entry.status === "loading"))
+                return;
+            finish({ ...update, requestId });
+        });
+        const timeout = setTimeout(() => {
+            const loading = latestEntries
+                .filter((entry) => entry.status === "loading")
+                .map((entry) => entry.provider)
+                .join(", ");
+            fail(new Error(loading
+                ? `Timed out waiting for providers: ${loading}`
+                : "Timed out waiting for provider discovery"));
+        }, timeoutMs);
+        void daemonClient
+            .getProvidersSnapshot(snapshotOptions)
+            .then((snapshot) => {
+            requestId = snapshot.requestId;
+            snapshotCwd = snapshot.cwd;
+            latestEntries = snapshot.entries;
+            if (!snapshot.entries.some((entry) => entry.status === "loading")) {
+                finish(snapshot);
+                return;
+            }
+            const pendingUpdate = pendingUpdates.get(snapshotCwd);
+            if (pendingUpdate && !pendingUpdate.entries.some((entry) => entry.status === "loading")) {
+                finish({ ...pendingUpdate, requestId });
+            }
+            return undefined;
+        })
+            .catch(fail);
+    });
+}
 function createGeneratedClientId() {
     const randomId = typeof globalThis.crypto?.randomUUID === "function"
         ? globalThis.crypto.randomUUID()

package/dist/terminal-stream-router.js

@@ -56,6 +56,7 @@ export class TerminalStreamRouter {
                 payload: encodeTerminalResizePayload({
                     rows: message.rows,
                     cols: message.cols,
+                    ...(message.intent ? { intent: message.intent } : {}),
                 }),
             });
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@otto-code/client",
-  "version": "0.8.12",
+  "version": "0.8.14",
   "description": "Otto client SDK package",
   "license": "AGPL-3.0-or-later",
   "files": [
@@ -21,6 +21,10 @@
     "./internal/daemon-client-transport-types": {
       "types": "./dist/daemon-client-transport-types.d.ts",
       "default": "./dist/daemon-client-transport-types.js"
+    },
+    "./internal/daemon-client-websocket-transport": {
+      "types": "./dist/daemon-client-websocket-transport.d.ts",
+      "default": "./dist/daemon-client-websocket-transport.js"
     }
   },
   "publishConfig": {
@@ -36,8 +40,8 @@
     "test": "vitest run"
   },
   "dependencies": {
-    "@otto-code/protocol": "0.8.12",
-    "@otto-code/relay": "0.8.12",
+    "@otto-code/protocol": "0.8.14",
+    "@otto-code/relay": "0.8.14",
     "zod": "^4.4.3"
   },
   "devDependencies": {