@dotcraft/sdk 0.5.9

package/dist/dotcraft.js

@@ -0,0 +1,819 @@
+import { userInfo } from "node:os";
+import { InternalAppServerClient } from "./appServerClient.js";
+import { JsonRpcMessage, textPart, } from "./models.js";
+import { WebSocketTransport } from "./transport.js";
+import { HubClient } from "./hubClient.js";
+import { InitializationError, TurnCancelledError, TurnFailedError, TurnInProgressError, } from "./errors.js";
+import { extractAgentReplyTextFromTurnCompletedParams, mergeReplyTextFromDeltaAndSnapshot, } from "./turnReply.js";
+export const APP_BINDING_ERROR_CODES = {
+    offline: "AppBindingOffline",
+    expired: "AppBindingExpired",
+    revoked: "AppBindingRevoked",
+    scopeDenied: "AppBindingScopeDenied",
+    toolUnavailable: "AppBindingToolUnavailable",
+    protocolViolation: "AppBindingProtocolViolation",
+};
+export function appBindingToolError(errorCode, errorMessage, structuredContent) {
+    return {
+        success: false,
+        errorCode,
+        errorMessage,
+        structuredContent,
+        contentItems: [{ type: "text", text: `${errorCode}: ${errorMessage}` }],
+    };
+}
+export function appBindingUnavailableError(state, message) {
+    if (state === "expired") {
+        return appBindingToolError(APP_BINDING_ERROR_CODES.expired, message ?? "The app binding has expired.");
+    }
+    if (state === "revoked") {
+        return appBindingToolError(APP_BINDING_ERROR_CODES.revoked, message ?? "The app binding was revoked.");
+    }
+    return appBindingToolError(APP_BINDING_ERROR_CODES.offline, message ?? "The app binding is offline. Reconnect the app or refresh the binding.");
+}
+/**
+ * Parse an App Binding handoff URL such as
+ * `app://dotcraft/connect?app=...&request=...&token=...&endpoint=...`.
+ *
+ * Deep links are activation hints, not authorization: always inspect the request
+ * over AppServer before rendering confirmation or accepting.
+ */
+export function parseAppBindingHandoff(url, options) {
+    const parsed = new URL(url);
+    const scheme = parsed.protocol.replace(/:$/, "");
+    if (options?.expectedScheme && scheme !== options.expectedScheme) {
+        throw new Error(`Unexpected handoff scheme '${scheme}', expected '${options.expectedScheme}'.`);
+    }
+    const operation = parsed.pathname.replace(/^\//, "");
+    const query = parsed.searchParams;
+    const appId = query.get("app") ?? "";
+    const requestId = query.get("request") ?? "";
+    const requestToken = query.get("token") ?? "";
+    if (!appId || !requestId || !requestToken) {
+        throw new Error("The handoff URL must contain app, request, and token query parameters.");
+    }
+    if (options?.expectedAppId && appId !== options.expectedAppId) {
+        throw new Error(`Unexpected handoff appId '${appId}', expected '${options.expectedAppId}'.`);
+    }
+    return {
+        scheme,
+        operation,
+        appId,
+        requestId,
+        requestToken,
+        appServerUrl: query.get("endpoint") ?? undefined,
+    };
+}
+function defaultUserId() {
+    try {
+        return userInfo().username || "local-user";
+    }
+    catch {
+        return "local-user";
+    }
+}
+function normalizeIdentity(options = {}) {
+    return {
+        channelName: options.channelName ?? "sdk",
+        userId: options.userId ?? defaultUserId(),
+        ...(options.workspacePath ? { workspacePath: options.workspacePath } : {}),
+        ...(options.channelContext ? { channelContext: options.channelContext } : {}),
+    };
+}
+function normalizeRunInput(input, sender) {
+    if (typeof input === "string")
+        return { input: [textPart(input)], sender };
+    if (Array.isArray(input))
+        return { input, sender };
+    return { input: input.input, sender: input.sender ?? sender };
+}
+function toContractSender(sender) {
+    if (!sender)
+        return undefined;
+    return {
+        ...sender,
+        senderName: sender.senderName ?? sender.senderId,
+        senderRole: sender.senderRole ?? "user",
+    };
+}
+function stripRuntimeDynamicToolHandlers(tools) {
+    if (tools === undefined)
+        return undefined;
+    return tools.map((declaration) => {
+        if (declaration.type === "namespace") {
+            return {
+                ...declaration,
+                tools: declaration.tools.map(({ handler: _handler, ...tool }) => tool),
+            };
+        }
+        const { handler: _handler, ...tool } = declaration;
+        return tool;
+    });
+}
+function toolKey(threadId, namespace, name) {
+    return `${threadId}\u0000${namespace ?? ""}\u0000${name}`;
+}
+function methodToRunEventType(method) {
+    switch (method) {
+        case "thread/started": return "thread_started";
+        case "thread/resumed": return "thread_resumed";
+        case "thread/statusChanged": return "thread_status_changed";
+        case "thread/runtimeChanged": return "thread_runtime_changed";
+        case "thread/queue/updated": return "queue_updated";
+        case "turn/started": return "turn_started";
+        case "item/started": return "item_started";
+        case "item/completed": return "item_completed";
+        case "item/agentMessage/delta": return "agent_message_delta";
+        case "item/reasoning/delta": return "reasoning_delta";
+        case "item/toolCall/argumentsDelta": return "tool_arguments_delta";
+        case "item/approval/resolved": return "approval_resolved";
+        case "item/usage/delta": return "usage_delta";
+        case "subagent/progress": return "subagent_progress";
+        case "plan/updated": return "plan_updated";
+        case "system/event": return "system_event";
+        case "turn/completed": return "completed";
+        case "turn/failed": return "failed";
+        case "turn/cancelled": return "cancelled";
+        default: return "raw";
+    }
+}
+function paramsRecord(raw) {
+    return raw && typeof raw === "object" ? raw : {};
+}
+function eventTurn(params) {
+    const raw = params.turn;
+    return raw && typeof raw === "object" ? raw : null;
+}
+function resolveThreadId(fallbackThreadId, params) {
+    if (typeof params.threadId === "string")
+        return params.threadId;
+    const turn = params.turn;
+    if (turn && typeof turn === "object" && typeof turn.threadId === "string") {
+        return turn.threadId;
+    }
+    const thread = params.thread;
+    if (thread && typeof thread === "object" && typeof thread.id === "string") {
+        return thread.id === fallbackThreadId ? fallbackThreadId : fallbackThreadId;
+    }
+    return fallbackThreadId;
+}
+function abortError() {
+    const error = new Error("Operation was aborted.");
+    error.name = "AbortError";
+    return error;
+}
+class RunReducer {
+    itemOrder = [];
+    itemSeen = new Set();
+    perItemDelta = new Map();
+    activeAgentItemId = null;
+    lastDeltaAgentItemId = null;
+    orphanDelta = "";
+    apply(event) {
+        const params = paramsRecord(event.params);
+        if (event.method === "item/started") {
+            const item = paramsRecord(params.item);
+            if (item.type === "agentMessage" && typeof item.id === "string" && item.id) {
+                this.activeAgentItemId = item.id;
+                this.lastDeltaAgentItemId = item.id;
+                this.pushOrder(item.id);
+            }
+            return;
+        }
+        if (event.method === "item/agentMessage/delta") {
+            const delta = typeof params.delta === "string" ? params.delta : "";
+            const explicit = typeof params.itemId === "string" && params.itemId ? params.itemId : null;
+            const itemId = explicit ?? this.activeAgentItemId ?? this.lastDeltaAgentItemId;
+            if (itemId) {
+                this.pushOrder(itemId);
+                this.perItemDelta.set(itemId, (this.perItemDelta.get(itemId) ?? "") + delta);
+                this.lastDeltaAgentItemId = itemId;
+                if (!this.activeAgentItemId)
+                    this.activeAgentItemId = itemId;
+            }
+            else {
+                this.orphanDelta += delta;
+            }
+            return;
+        }
+        if (event.method === "item/completed") {
+            const item = paramsRecord(params.item);
+            if (item.type !== "agentMessage")
+                return;
+            const itemId = typeof item.id === "string" ? item.id : "";
+            if (!itemId)
+                return;
+            this.pushOrder(itemId);
+            const payload = paramsRecord(item.payload);
+            const snapshot = typeof payload.text === "string" ? payload.text : "";
+            const delta = this.perItemDelta.get(itemId) ?? "";
+            this.perItemDelta.set(itemId, mergeReplyTextFromDeltaAndSnapshot(delta, snapshot));
+            if (this.activeAgentItemId === itemId)
+                this.activeAgentItemId = null;
+            this.lastDeltaAgentItemId = itemId;
+        }
+    }
+    textFromCompleted(params) {
+        const snapshot = extractAgentReplyTextFromTurnCompletedParams(params);
+        const delta = this.itemOrder.map((id) => this.perItemDelta.get(id) ?? "").join("") + this.orphanDelta;
+        return mergeReplyTextFromDeltaAndSnapshot(delta, snapshot);
+    }
+    pushOrder(itemId) {
+        if (!itemId || this.itemSeen.has(itemId))
+            return;
+        this.itemSeen.add(itemId);
+        this.itemOrder.push(itemId);
+    }
+}
+class ThreadManagerImpl {
+    sdk;
+    constructor(sdk) {
+        this.sdk = sdk;
+    }
+    async getOrCreate(options = {}) {
+        const identity = normalizeIdentity(options);
+        const threads = await this.sdk.wire.threadList({
+            ...identity,
+            includeArchived: options.includeArchived ?? false,
+        });
+        const reusable = threads.find((thread) => thread.status === "active" || thread.status === "paused");
+        if (reusable) {
+            if (reusable.status === "paused") {
+                return await this.resume(reusable.id, {
+                    dynamicTools: options.dynamicTools,
+                    additionalContext: options.additionalContext,
+                });
+            }
+            const snapshot = await this.sdk.wire.threadRead(reusable.id);
+            const thread = new DotCraftThread(this.sdk, snapshot, identity);
+            thread.bindDynamicTools(options.dynamicTools);
+            return thread;
+        }
+        return await this.start(options);
+    }
+    async start(options = {}) {
+        const identity = normalizeIdentity(options);
+        const snapshot = await this.sdk.wire.threadStart({
+            ...identity,
+            displayName: options.displayName,
+            historyMode: options.historyMode,
+            config: options.config,
+            dynamicTools: stripRuntimeDynamicToolHandlers(options.dynamicTools),
+            additionalContext: options.additionalContext,
+        });
+        const thread = new DotCraftThread(this.sdk, snapshot, identity);
+        thread.bindDynamicTools(options.dynamicTools);
+        return thread;
+    }
+    async resume(threadId, options = {}) {
+        const snapshot = await this.sdk.wire.threadResume(threadId, {
+            dynamicTools: stripRuntimeDynamicToolHandlers(options.dynamicTools),
+            additionalContext: options.additionalContext,
+        });
+        const thread = new DotCraftThread(this.sdk, snapshot, {
+            channelName: snapshot.originChannel || "sdk",
+            userId: snapshot.userId || defaultUserId(),
+            workspacePath: snapshot.workspacePath || undefined,
+        });
+        thread.bindDynamicTools(options.dynamicTools);
+        return thread;
+    }
+    async list(options = {}) {
+        const page = await this.listPage(options);
+        return page.data;
+    }
+    async listPage(options = {}) {
+        const identity = normalizeIdentity(options);
+        return await this.sdk.wire.threadListPage({
+            ...identity,
+            scope: options.scope,
+            includeArchived: options.includeArchived ?? false,
+            query: options.query,
+            limit: options.limit,
+            cursor: options.cursor,
+        });
+    }
+    async read(threadId) {
+        return await this.sdk.wire.threadRead(threadId);
+    }
+    async listTurns(threadId, options = {}) {
+        return await this.sdk.wire.threadTurnsList({ threadId, ...options });
+    }
+    async listItems(threadId, options = {}) {
+        return await this.sdk.wire.threadItemsList({ threadId, ...options });
+    }
+}
+class AppBindingManagerImpl {
+    sdk;
+    constructor(sdk) {
+        this.sdk = sdk;
+    }
+    async listApps(params = {}) {
+        const result = await this.sdk.request("app/list", {
+            includeCatalog: params.includeCatalog ?? true,
+            includeDisabled: params.includeDisabled ?? true,
+            threadId: params.threadId,
+            forceRefresh: params.forceRefresh ?? false,
+        });
+        return result.apps ?? [];
+    }
+    async viewApp(appId, params = {}) {
+        const result = await this.sdk.request("app/view", {
+            appId,
+            threadId: params.threadId,
+        });
+        if (!result.app)
+            throw new Error(`App '${appId}' was not returned by app/view.`);
+        return result.app;
+    }
+    async startConnection(appId, params = {}) {
+        return await this.sdk.request("app/connection/start", {
+            appId,
+            handoffMode: params.handoffMode,
+            returnTo: params.returnTo,
+        });
+    }
+    async connect(params) {
+        return await this.sdk.request("app/connection/connect", {
+            connectionRequestId: params.connectionRequestId,
+            requestToken: params.requestToken,
+            accountLabel: params.accountLabel,
+        });
+    }
+    async connectionStatus(appId) {
+        return await this.sdk.request("app/connection/status", { appId });
+    }
+    async revokeConnection(appId, reason) {
+        return await this.sdk.request("app/connection/revoke", { appId, reason });
+    }
+    async publishSurface(params) {
+        return await this.sdk.request("app/surface/publish", {
+            surfaceId: params.surfaceId,
+            endpoint: params.endpoint,
+            bearer: params.bearer,
+        });
+    }
+    async resolveSurface(params) {
+        return await this.sdk.request("app/surface/resolve", {
+            appId: params.appId,
+            surfaceId: params.surfaceId,
+        });
+    }
+    async authenticate(appId, credential) {
+        return await this.sdk.request("app/connection/authenticate", { appId, credential });
+    }
+    async refreshCredential() {
+        return await this.sdk.request("app/connection/refresh", {});
+    }
+    async activate(params) {
+        return await this.sdk.request("app/binding/activate", params);
+    }
+    async rebind(params) {
+        return await this.sdk.request("app/binding/rebind", params);
+    }
+    async confirmCapabilities(threadId, bindingId, candidateRevision, decision) {
+        return await this.sdk.request("thread/appBindings/confirmCapabilities", { threadId, bindingId, candidateRevision, decision });
+    }
+    async enable(threadId, appId) {
+        return await this.sdk.request("thread/appBindings/enable", {
+            threadId,
+            appId,
+        });
+    }
+    async createSocialBindingRequest(params) {
+        return await this.sdk.request("thread/socialBindings/request/create", {
+            threadId: params.threadId,
+            channelName: params.channelName,
+        });
+    }
+    async getBindingRequest(params) {
+        return await this.sdk.request(params.bindCode ? "app/socialBinding/request/get" : "app/binding/request/get", params.bindCode ? { code: params.bindCode } : {
+            bindingRequestId: params.bindingRequestId,
+            requestToken: params.requestToken,
+        });
+    }
+    async acceptSocialBinding(params) {
+        const target = params.socialTarget;
+        return await this.sdk.request("app/socialBinding/accept", {
+            code: params.requestToken,
+            target,
+        });
+    }
+    async resolveSocialBinding(params) {
+        return await this.sdk.request("app/socialBinding/resolve", {
+            channelName: params.channelName,
+            accountId: params.accountId,
+            conversationKind: params.conversationKind,
+            conversationId: params.conversationId,
+        });
+    }
+    async enqueueThreadInput(params) {
+        return await this.sdk.request("app/threadInput/enqueue", {
+            ...params,
+            sender: toContractSender(params.sender),
+        });
+    }
+    async listThreadBindings(threadId, includeRevoked = false) {
+        const result = await this.sdk.request("thread/appBindings/list", {
+            threadId,
+            includeRevoked,
+        });
+        return result.bindings ?? [];
+    }
+    async revokeThreadBinding(threadId, bindingId, reason) {
+        return await this.sdk.request("thread/appBindings/revoke", {
+            threadId,
+            bindingId,
+            reason,
+        });
+    }
+    async refreshThreadBindings(threadId, bindingId) {
+        const result = await this.sdk.request("thread/appBindings/list", { threadId, bindingId });
+        return result.bindings ?? [];
+    }
+}
+class ModelManagerImpl {
+    sdk;
+    constructor(sdk) {
+        this.sdk = sdk;
+    }
+    async list() {
+        const result = await this.sdk.request("model/list", {});
+        return result.models ?? [];
+    }
+}
+class McpRuntimeManagerImpl {
+    sdk;
+    constructor(sdk) {
+        this.sdk = sdk;
+    }
+    listStatus(params = {}) {
+        return this.sdk.request("mcpServerStatus/list", params);
+    }
+    readResource(params) {
+        return this.sdk.request("mcpServer/resource/read", params);
+    }
+    callTool(params) {
+        return this.sdk.request("mcpServer/tool/call", params);
+    }
+    loginOAuth(params) {
+        return this.sdk.request("mcpServer/oauth/login", params);
+    }
+    reload() {
+        return this.sdk.request("config/mcpServer/reload", {});
+    }
+}
+export class DotCraft {
+    wire;
+    serverInfo;
+    capabilities;
+    approvalHandler;
+    userInputHandler;
+    threads;
+    appBindings;
+    models;
+    mcpRuntime;
+    constructor(wire, serverInfo, capabilities, approvalHandler, userInputHandler) {
+        this.wire = wire;
+        this.serverInfo = serverInfo;
+        this.capabilities = capabilities;
+        this.approvalHandler = approvalHandler;
+        this.userInputHandler = userInputHandler;
+        this.threads = new ThreadManagerImpl(this);
+        this.appBindings = new AppBindingManagerImpl(this);
+        this.models = new ModelManagerImpl(this);
+        this.mcpRuntime = new McpRuntimeManagerImpl(this);
+        this.installServerRequestHandlers();
+    }
+    static async local(options) {
+        if (!options.workspacePath?.trim()) {
+            throw new InitializationError("workspacePath is required for DotCraft.local().");
+        }
+        const hub = new HubClient({
+            executable: options.executable,
+            expectedExecutable: options.expectedExecutable,
+            binaryMatchPolicy: options.binaryMatchPolicy,
+            hubStartupTimeoutMs: options.hubStartupTimeoutMs,
+            homeDir: options.homeDir,
+        });
+        const ensured = await hub.ensureAppServer(options.workspacePath, {
+            clientName: options.clientName ?? "dotcraft-sdk",
+            clientVersion: options.clientVersion ?? "0.1.0",
+        });
+        const wsUrl = ensured.endpoints.appServerWebSocket;
+        if (!wsUrl)
+            throw new InitializationError("Hub response did not include endpoints.appServerWebSocket.");
+        return await DotCraft.connect(new WebSocketTransport({ url: wsUrl }), options);
+    }
+    static async localChat(options = {}) {
+        const hub = new HubClient({
+            executable: options.executable,
+            expectedExecutable: options.expectedExecutable,
+            binaryMatchPolicy: options.binaryMatchPolicy,
+            hubStartupTimeoutMs: options.hubStartupTimeoutMs,
+            homeDir: options.homeDir,
+        });
+        const ensured = await hub.ensureDefaultChatAppServer({
+            clientName: options.clientName ?? "dotcraft-sdk",
+            clientVersion: options.clientVersion ?? "0.1.0",
+        });
+        const wsUrl = ensured.endpoints.appServerWebSocket;
+        if (!wsUrl)
+            throw new InitializationError("Hub response did not include endpoints.appServerWebSocket.");
+        return await DotCraft.connect(new WebSocketTransport({ url: wsUrl }), {
+            ...options,
+            workspacePath: ensured.workspacePath,
+        });
+    }
+    static async remote(options) {
+        return await DotCraft.connect(new WebSocketTransport({ url: options.url, token: options.token }), options);
+    }
+    request(method, params) {
+        return this.wire.request(method, params);
+    }
+    requestRaw(method, params) {
+        return this.wire.requestRaw(method, params);
+    }
+    on(event, handler) {
+        return this.wire.on(event, handler);
+    }
+    onRaw(event, handler) {
+        return this.wire.onRaw(event, handler);
+    }
+    async close() {
+        await this.wire.stop();
+    }
+    registerDynamicToolHandler(threadId, namespace, name, handler) {
+        const key = toolKey(threadId, namespace, name);
+        this.dynamicToolHandlers.set(key, handler);
+        return () => this.dynamicToolHandlers.delete(key);
+    }
+    dynamicToolHandlers = new Map();
+    static async connect(transport, options) {
+        if (options.capabilities?.approvalSupport === true && !options.approvalHandler) {
+            throw new InitializationError("approvalSupport requires an approvalHandler.");
+        }
+        if (options.capabilities?.requestUserInputSupport === true && !options.userInputHandler) {
+            throw new InitializationError("requestUserInputSupport requires a userInputHandler.");
+        }
+        const wire = new InternalAppServerClient(transport, { autoReconnect: true });
+        let sdk;
+        if (options.approvalHandler) {
+            wire.registerServerRequestHandler("item/approval/request", async (_id, params) => ({
+                decision: await options.approvalHandler(params),
+            }));
+        }
+        if (options.userInputHandler) {
+            wire.registerServerRequestHandler("item/tool/requestUserInput", async (_id, params) => (await options.userInputHandler(params)));
+        }
+        wire.registerServerRequestHandler("item/tool/call", async (_id, params) => {
+            const request = params;
+            const handler = sdk?.dynamicToolHandlers.get(toolKey(request.threadId, request.namespace, request.tool));
+            if (!handler) {
+                return { success: false, errorCode: "UnsupportedTool", errorMessage: "No handler registered for this dynamic tool." };
+            }
+            try {
+                return await handler(request);
+            }
+            catch (error) {
+                return {
+                    success: false,
+                    errorCode: "AdapterToolCallFailed",
+                    errorMessage: error instanceof Error ? error.message : String(error),
+                };
+            }
+        });
+        await wire.connect();
+        const initialized = await wire.initialize({
+            clientName: options.clientName ?? "dotcraft-sdk",
+            clientVersion: options.clientVersion ?? "0.1.0",
+            clientTitle: options.clientTitle,
+            approvalSupport: Boolean(options.approvalHandler),
+            requestUserInputSupport: Boolean(options.userInputHandler),
+            streamingSupport: true,
+            configChange: true,
+            extraCapabilities: options.capabilities,
+        });
+        sdk = new DotCraft(wire, initialized.serverInfo, initialized.capabilities, options.approvalHandler, options.userInputHandler);
+        return sdk;
+    }
+    installServerRequestHandlers() {
+        if (this.approvalHandler) {
+            this.wire.registerServerRequestHandler("item/approval/request", async (_id, params) => ({
+                decision: await this.approvalHandler(params),
+            }));
+        }
+        if (this.userInputHandler) {
+            this.wire.registerServerRequestHandler("item/tool/requestUserInput", async (_id, params) => (await this.userInputHandler(params)));
+        }
+        this.wire.registerServerRequestHandler("item/tool/call", async (_id, params) => {
+            const request = params;
+            const handler = this.dynamicToolHandlers.get(toolKey(request.threadId, request.namespace, request.tool));
+            if (!handler) {
+                return { success: false, errorCode: "UnsupportedTool", errorMessage: "No handler registered for this dynamic tool." };
+            }
+            try {
+                return await handler(request);
+            }
+            catch (error) {
+                return {
+                    success: false,
+                    errorCode: "AdapterToolCallFailed",
+                    errorMessage: error instanceof Error ? error.message : String(error),
+                };
+            }
+        });
+    }
+}
+export class DotCraftThread {
+    sdk;
+    identity;
+    id;
+    cached;
+    dynamicToolUnsubscribes = [];
+    constructor(sdk, snapshot, identity) {
+        this.sdk = sdk;
+        this.identity = identity;
+        this.cached = snapshot;
+        this.id = snapshot.id;
+    }
+    snapshot() {
+        return this.cached;
+    }
+    async refresh() {
+        this.cached = await this.sdk.wire.threadRead(this.id);
+        return this.cached;
+    }
+    async listTurns(options = {}) {
+        return await this.sdk.wire.threadTurnsList({ threadId: this.id, ...options });
+    }
+    async listItems(options = {}) {
+        return await this.sdk.wire.threadItemsList({ threadId: this.id, ...options });
+    }
+    async subscribe(options = {}) {
+        await this.sdk.wire.threadSubscribe(this.id, options.replayRecent ?? false);
+        return {
+            threadId: this.id,
+            unsubscribe: async () => {
+                await this.unsubscribe();
+            },
+        };
+    }
+    async unsubscribe() {
+        await this.sdk.wire.threadUnsubscribe(this.id);
+    }
+    async run(input, options = {}) {
+        let queued = null;
+        for await (const event of this.runStreamed(input, options)) {
+            if (event.type === "completed" && event.result)
+                return event.result;
+            if (event.type === "queue_updated") {
+                queued = {
+                    thread: this.cached,
+                    turn: null,
+                    text: "",
+                    items: [],
+                    rawEvents: options.collectRawEvents ? [event.raw] : undefined,
+                    queuedInput: event.queuedInput,
+                };
+            }
+            if (event.type === "failed") {
+                throw new TurnFailedError(event.error ?? "SessionTurn failed.", event.turn);
+            }
+            if (event.type === "cancelled") {
+                throw new TurnCancelledError("SessionTurn was cancelled.", event.turn);
+            }
+        }
+        if (queued)
+            return queued;
+        throw new TurnFailedError("Run finished without a terminal event.");
+    }
+    async *runStreamed(input, options = {}) {
+        if (options.abortSignal?.aborted)
+            throw abortError();
+        const normalized = normalizeRunInput(input, options.sender);
+        const reducer = new RunReducer();
+        const rawEvents = [];
+        const eventStream = this.sdk.wire.streamEvents(this.id);
+        let turn;
+        let abortListener = null;
+        try {
+            try {
+                turn = await this.sdk.wire.turnStart(this.id, normalized.input, toContractSender(normalized.sender));
+            }
+            catch (error) {
+                await eventStream.return?.();
+                if (error instanceof TurnInProgressError && options.enqueueIfBusy) {
+                    const queued = await this.enqueue({ input: normalized.input, sender: normalized.sender });
+                    const raw = JsonRpcMessage.fromDict({ method: "thread/queue/updated", params: queued.raw });
+                    yield {
+                        type: "queue_updated",
+                        threadId: this.id,
+                        raw,
+                        queuedInput: queued.queuedInput,
+                    };
+                    return;
+                }
+                throw error;
+            }
+            if (options.abortSignal) {
+                abortListener = () => {
+                    void this.interrupt(turn.id).catch(() => { });
+                };
+                options.abortSignal.addEventListener("abort", abortListener, { once: true });
+            }
+            for await (const raw of eventStream) {
+                rawEvents.push(raw);
+                reducer.apply(raw);
+                const params = paramsRecord(raw.params);
+                const resolvedTurn = eventTurn(params);
+                const type = methodToRunEventType(raw.method);
+                const base = {
+                    type,
+                    threadId: resolveThreadId(this.id, params),
+                    turnId: typeof params.turnId === "string" ? params.turnId : resolvedTurn?.id,
+                    raw,
+                };
+                if (type === "agent_message_delta" || type === "reasoning_delta" || type === "tool_arguments_delta") {
+                    base.delta = typeof params.delta === "string" ? params.delta : "";
+                }
+                if (type === "item_started" || type === "item_completed" || type === "approval_resolved") {
+                    base.item = params.item;
+                }
+                if (resolvedTurn)
+                    base.turn = resolvedTurn;
+                if (type === "completed" && resolvedTurn) {
+                    this.cached = await this.sdk.wire.threadRead(this.id);
+                    const text = reducer.textFromCompleted(params);
+                    base.result = {
+                        thread: this.cached,
+                        turn: resolvedTurn,
+                        text,
+                        items: resolvedTurn.items ?? [],
+                        usage: resolvedTurn.tokenUsage,
+                        rawEvents: options.collectRawEvents ? [...rawEvents] : undefined,
+                    };
+                    yield base;
+                    return;
+                }
+                if (type === "failed") {
+                    base.error = typeof params.error === "string" ? params.error : resolvedTurn?.error ?? "SessionTurn failed.";
+                    yield base;
+                    return;
+                }
+                if (type === "cancelled") {
+                    yield base;
+                    return;
+                }
+                yield base;
+            }
+        }
+        finally {
+            if (abortListener && options.abortSignal) {
+                options.abortSignal.removeEventListener("abort", abortListener);
+            }
+            await eventStream.return?.();
+        }
+    }
+    async enqueue(input, options = {}) {
+        const normalized = normalizeRunInput(input, options.sender);
+        const raw = await this.sdk.wire.turnEnqueue(this.id, normalized.input, toContractSender(normalized.sender));
+        return {
+            queuedInput: raw.queuedInput,
+            queuedInputs: raw.queuedInputs,
+            raw,
+        };
+    }
+    async interrupt(turnId) {
+        await this.sdk.wire.turnInterrupt(this.id, turnId);
+    }
+    async setMode(mode) {
+        await this.sdk.wire.threadSetMode(this.id, mode);
+    }
+    async archive() {
+        await this.sdk.wire.threadArchive(this.id);
+    }
+    async delete() {
+        await this.sdk.wire.threadDelete(this.id);
+    }
+    onToolCall(namespace, name, handler) {
+        return this.sdk.registerDynamicToolHandler(this.id, namespace, name, handler);
+    }
+    bindDynamicTools(tools) {
+        for (const unsubscribe of this.dynamicToolUnsubscribes.splice(0))
+            unsubscribe();
+        if (!tools)
+            return;
+        for (const declaration of tools) {
+            if (declaration.type === "namespace") {
+                for (const tool of declaration.tools) {
+                    this.dynamicToolUnsubscribes.push(this.onToolCall(declaration.name, tool.name, tool.handler));
+                }
+            }
+            else {
+                this.dynamicToolUnsubscribes.push(this.onToolCall(null, declaration.name, declaration.handler));
+            }
+        }
+    }
+}
+//# sourceMappingURL=dotcraft.js.map