@kaoruisaac/pedelec 0.1.0 → 0.1.3

package/dist/index.js

@@ -1,6 +1,92 @@
 import { PEDELEC_EXTENSION_ID } from "./extension-id.js";
 const SDK_EXTERNAL_PORT_NAME = "pedelec-sdk-external";
 const DEFAULT_BRIDGE_TIMEOUT_MS = 30_000;
+const TOOL_NAME_PATTERN = /^[a-zA-Z][a-zA-Z0-9_.-]*$/;
+export function defineTool(tool) {
+    return tool;
+}
+function normalizeSkillsInput(value) {
+    const handlers = new Map();
+    if (value === undefined)
+        return { handlers };
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        throw makeError("INVALID_INPUT", "skills must be an object");
+    }
+    const skills = value;
+    if (typeof skills.guidance !== "string") {
+        throw makeError("INVALID_INPUT", "skills.guidance must be a string");
+    }
+    if (!Array.isArray(skills.tools)) {
+        throw makeError("INVALID_INPUT", "skills.tools must be an array");
+    }
+    const seen = new Set();
+    const tools = skills.tools.map((tool, index) => {
+        if (!tool || typeof tool !== "object" || Array.isArray(tool)) {
+            throw makeError("INVALID_INPUT", "skills.tools entries must be objects", { index });
+        }
+        const rawTool = tool;
+        if (typeof rawTool.name !== "string" || !TOOL_NAME_PATTERN.test(rawTool.name)) {
+            throw makeError("INVALID_INPUT", "tool name is invalid", { index, toolName: rawTool.name });
+        }
+        if (seen.has(rawTool.name)) {
+            throw makeError("INVALID_INPUT", "duplicate tool name", { toolName: rawTool.name });
+        }
+        seen.add(rawTool.name);
+        if (typeof rawTool.description !== "string" || rawTool.description.trim().length === 0) {
+            throw makeError("INVALID_INPUT", "tool description must be a non-empty string", {
+                toolName: rawTool.name,
+            });
+        }
+        if (rawTool.timeoutMs !== undefined &&
+            (!Number.isInteger(rawTool.timeoutMs) || rawTool.timeoutMs <= 0)) {
+            throw makeError("INVALID_INPUT", "tool timeoutMs must be a positive integer", {
+                toolName: rawTool.name,
+            });
+        }
+        if (rawTool.handler !== undefined && typeof rawTool.handler !== "function") {
+            throw makeError("INVALID_INPUT", "tool handler must be a function", { toolName: rawTool.name });
+        }
+        if (rawTool.input !== undefined) {
+            throw makeError("INVALID_INPUT", "tool input is no longer supported; use argsSchema", {
+                toolName: rawTool.name,
+            });
+        }
+        const argsSchema = normalizeToolArgsSchema(rawTool.argsSchema, rawTool.name);
+        if (rawTool.handler)
+            handlers.set(rawTool.name, rawTool.handler);
+        return {
+            name: rawTool.name,
+            description: rawTool.description,
+            argsSchema,
+            ...(rawTool.timeoutMs === undefined ? {} : { timeoutMs: rawTool.timeoutMs }),
+        };
+    });
+    return {
+        manifest: {
+            guidance: skills.guidance,
+            tools,
+        },
+        handlers,
+    };
+}
+function normalizeToolArgsSchema(argsSchema, toolName) {
+    if (!argsSchema || typeof argsSchema !== "object" || Array.isArray(argsSchema)) {
+        throw makeError("INVALID_INPUT", "tool argsSchema must be an object", { toolName });
+    }
+    const schema = argsSchema;
+    if (schema.type !== "object") {
+        throw makeError("INVALID_INPUT", "tool argsSchema must describe an object", { toolName });
+    }
+    try {
+        return JSON.parse(JSON.stringify(schema));
+    }
+    catch (err) {
+        throw makeError("INVALID_INPUT", "tool argsSchema must be serializable", {
+            toolName,
+            error: err instanceof Error ? err.message : String(err),
+        });
+    }
+}
 export class Pedelec {
     pageWindow;
     channelId;
@@ -28,13 +114,14 @@ export class Pedelec {
             input: {
                 provider: resolvedInput.provider,
                 model: resolvedInput.model,
-                skillsUrls: resolvedInput.skillsUrls,
+                skills: resolvedInput.skills,
+                autoEndOnDisconnect: resolvedInput.autoEndOnDisconnect,
             },
         });
         if (!result.sessionId) {
             throw makeError("SDK_PROTOCOL_ERROR", "create_session response did not include sessionId");
         }
-        return this.registerSession(result.sessionId, resolvedInput.provider, resolvedInput.model);
+        return this.registerSession(result.sessionId, resolvedInput.provider, resolvedInput.model, resolvedInput.inlineToolHandlers);
     }
     async listProviders() {
         const result = await this.request("list_providers");
@@ -130,28 +217,31 @@ export class Pedelec {
         const provider = typeof raw.provider === "string" ? raw.provider.trim() : "";
         const hasProvider = provider.length > 0;
         const hasModel = raw.model !== undefined;
+        const autoEndOnDisconnect = raw.autoEndOnDisconnect !== false;
+        const normalizedSkills = normalizeSkillsInput(raw.skills);
         if (!hasProvider && hasModel) {
             throw makeError("INVALID_INPUT", "model cannot be provided without provider");
         }
-        const skillsUrls = Array.isArray(raw.skillsUrls) ? raw.skillsUrls : [];
         const userModel = typeof raw.model === "string" ? raw.model : undefined;
         if (!hasProvider) {
-            return this.resolveDefaultCreateSessionInput(skillsUrls);
+            return this.resolveDefaultCreateSessionInput(normalizedSkills, autoEndOnDisconnect);
         }
         if (!isProviderCode(provider)) {
             throw makeError("INVALID_INPUT", "provider is not supported", { provider });
         }
         let model = userModel;
         if (model === undefined) {
-            return this.resolveProviderOnlyCreateSessionInput(provider, skillsUrls);
+            return this.resolveProviderOnlyCreateSessionInput(provider, normalizedSkills, autoEndOnDisconnect);
         }
         return {
             provider: provider,
             model,
-            skillsUrls,
+            skills: normalizedSkills.manifest,
+            inlineToolHandlers: normalizedSkills.handlers,
+            autoEndOnDisconnect,
         };
     }
-    async resolveDefaultCreateSessionInput(skillsUrls) {
+    async resolveDefaultCreateSessionInput(normalizedSkills, autoEndOnDisconnect) {
         const settings = await this.getSettings();
         if (!settings.defaultProvider) {
             throw makeError("DEFAULT_PROVIDER_NOT_SET", "Default provider is not set. Open the Pedelec desktop app Settings page and choose a default provider.");
@@ -159,18 +249,20 @@ export class Pedelec {
         await this.assertDefaultProviderAvailable(settings.defaultProvider);
         return {
             provider: settings.defaultProvider,
-            model: settings.defaultModel ?? undefined,
-            skillsUrls,
+            model: settings.defaultModels[settings.defaultProvider] ?? undefined,
+            skills: normalizedSkills.manifest,
+            inlineToolHandlers: normalizedSkills.handlers,
+            autoEndOnDisconnect,
         };
     }
-    async resolveProviderOnlyCreateSessionInput(provider, skillsUrls) {
+    async resolveProviderOnlyCreateSessionInput(provider, normalizedSkills, autoEndOnDisconnect) {
         const settings = await this.getSettings();
         return {
             provider,
-            model: settings.defaultProvider === provider && settings.defaultModel
-                ? settings.defaultModel
-                : undefined,
-            skillsUrls,
+            model: settings.defaultModels[provider] ?? undefined,
+            skills: normalizedSkills.manifest,
+            inlineToolHandlers: normalizedSkills.handlers,
+            autoEndOnDisconnect,
         };
     }
     async assertDefaultProviderAvailable(provider) {
@@ -180,11 +272,13 @@ export class Pedelec {
             throw makeError("DEFAULT_PROVIDER_UNAVAILABLE", "Default provider is not currently available. Open the Pedelec desktop app Settings page and choose an available provider.", { provider });
         }
     }
-    registerSession(sessionId, provider, model) {
+    registerSession(sessionId, provider, model, inlineToolHandlers = new Map()) {
         const existing = this.sessions.get(sessionId);
-        if (existing)
+        if (existing) {
+            existing.replaceInlineToolHandlers(inlineToolHandlers);
             return existing;
-        const session = new PedelecSession(this, sessionId, provider, model);
+        }
+        const session = new PedelecSession(this, sessionId, provider, model, inlineToolHandlers);
         this.sessions.set(sessionId, session);
         return session;
     }
@@ -215,8 +309,12 @@ export class Pedelec {
             return;
         }
         if (isSessionEvent(message) && this.isNewEvent(message)) {
+            const eventReceivedAt = Date.now();
             if (message.sessionId) {
-                this.sessions.get(message.sessionId)?.handleEvent(message);
+                this.sessions.get(message.sessionId)?.handleEvent(message, {
+                    source: "core",
+                    eventReceivedAt,
+                });
             }
             else if (message.type === "error") {
                 this.broadcastError(normalizeError(message.error, "SDK_TRANSPORT_ERROR", "Pedelec transport error"));
@@ -260,7 +358,7 @@ export class Pedelec {
     }
     broadcastError(error) {
         for (const session of this.sessions.values()) {
-            session.handleEvent({ type: "error", sessionId: session.sessionId, error });
+            session.handleEvent({ type: "error", sessionId: session.sessionId, error }, { source: "sdk" });
         }
     }
 }
@@ -269,27 +367,84 @@ export class PedelecSession {
     sessionId;
     provider;
     model;
+    sessionCreatedAt = Date.now();
     status = "idle";
     pendingSend = null;
-    toolHandler = null;
+    pendingPrepare = null;
+    preparePromise = null;
+    prepared = false;
+    activeTurn = null;
+    genericToolHandler = null;
+    inlineToolHandlers = new Map();
+    namedToolHandlers = new Map();
     chatHandlers = new Set();
     errorHandlers = new Set();
     statusHandlers = new Set();
     endedHandlers = new Set();
-    constructor(client, sessionId, provider, model) {
+    constructor(client, sessionId, provider, model, inlineToolHandlers = new Map()) {
         this.client = client;
         this.sessionId = sessionId;
         this.provider = provider;
         this.model = model;
+        this.inlineToolHandlers = new Map(inlineToolHandlers);
     }
-    sendText(text) {
+    prepare() {
         if (this.status === "ended") {
             return Promise.reject(makeError("SESSION_ENDED", "session has ended", { sessionId: this.sessionId }));
         }
         if (this.pendingSend) {
             return Promise.reject(makeError("SESSION_BUSY", "session is already running", { sessionId: this.sessionId }));
         }
-        this.setStatus("running");
+        if (this.prepared) {
+            return Promise.resolve();
+        }
+        if (this.preparePromise) {
+            return this.preparePromise;
+        }
+        const turn = createTurn("prepare");
+        this.activeTurn = turn;
+        this.setStatus("running", { source: "sdk" });
+        const donePromise = new Promise((resolve, reject) => {
+            this.pendingPrepare = { resolve, reject };
+        });
+        const requestPromise = this.client
+            .request("prepare_session", {
+            sessionId: this.sessionId,
+        })
+            .catch((err) => {
+            const error = normalizeError(err, "PREPARE_FAILED", "prepare failed");
+            this.emitError(error, { source: "sdk" });
+            this.clearPendingPrepare();
+            this.finishActiveTurn(turn);
+            throw error;
+        });
+        this.preparePromise = Promise.all([requestPromise, donePromise])
+            .then(() => {
+            this.prepared = true;
+        })
+            .finally(() => {
+            this.preparePromise = null;
+        });
+        return this.preparePromise;
+    }
+    async sendText(text) {
+        if (this.preparePromise) {
+            try {
+                await this.preparePromise;
+            }
+            catch {
+                // prepare is an optimization; sendText falls back to the original first-run path.
+            }
+        }
+        if (this.status === "ended") {
+            return Promise.reject(makeError("SESSION_ENDED", "session has ended", { sessionId: this.sessionId }));
+        }
+        if (this.pendingSend || this.pendingPrepare) {
+            return Promise.reject(makeError("SESSION_BUSY", "session is already running", { sessionId: this.sessionId }));
+        }
+        const turn = createTurn("user");
+        this.activeTurn = turn;
+        this.setStatus("running", { source: "sdk" });
         const donePromise = new Promise((resolve, reject) => {
             this.pendingSend = { resolve, reject };
         });
@@ -300,8 +455,9 @@ export class PedelecSession {
         })
             .catch((err) => {
             const error = normalizeError(err, "SEND_TEXT_FAILED", "sendText failed");
+            this.emitError(error, { source: "sdk" });
             this.clearPendingSend();
-            this.emitError(error);
+            this.finishActiveTurn(turn);
             throw error;
         });
         return Promise.all([requestPromise, donePromise]).then(() => undefined);
@@ -310,11 +466,27 @@ export class PedelecSession {
         this.chatHandlers.add(handler);
         return () => this.chatHandlers.delete(handler);
     }
-    onTool(handler) {
-        this.toolHandler = handler;
+    onTool(toolNameOrHandler, maybeHandler) {
+        if (typeof toolNameOrHandler === "string") {
+            const toolName = toolNameOrHandler;
+            if (!TOOL_NAME_PATTERN.test(toolName)) {
+                throw makeError("INVALID_INPUT", "tool name is invalid", { toolName });
+            }
+            if (typeof maybeHandler !== "function") {
+                throw makeError("INVALID_INPUT", "tool handler must be a function", { toolName });
+            }
+            this.namedToolHandlers.set(toolName, maybeHandler);
+            return () => {
+                if (this.namedToolHandlers.get(toolName) === maybeHandler) {
+                    this.namedToolHandlers.delete(toolName);
+                }
+            };
+        }
+        const handler = toolNameOrHandler;
+        this.genericToolHandler = handler;
         return () => {
-            if (this.toolHandler === handler) {
-                this.toolHandler = null;
+            if (this.genericToolHandler === handler) {
+                this.genericToolHandler = null;
             }
         };
     }
@@ -343,67 +515,83 @@ export class PedelecSession {
         }
         catch (err) {
             const error = normalizeError(err, "END_SESSION_FAILED", "end failed");
-            this.emitError(error);
+            this.emitError(error, { source: "sdk" });
             throw error;
         }
-        this.markEnded();
+        this.markEnded({ source: "sdk" });
         this.client.unregisterSession(this.sessionId);
     }
-    handleEvent(event) {
+    handleEvent(event, meta = { source: "sdk" }) {
         if (event.type === "chat_delta") {
+            const turn = this.requireActiveTurn("chat_delta", meta);
+            if (!turn)
+                return;
+            if (turn.kind === "prepare")
+                return;
             for (const handler of this.chatHandlers) {
-                handler(event.text);
+                handler(event.text, this.createChatContext(meta, turn));
             }
             return;
         }
         if (event.type === "status_changed") {
-            this.setStatus(event.status);
+            this.setStatus(event.status, meta);
             if (event.status === "idle") {
-                this.resolvePendingSend();
+                this.resolveActivePending();
             }
             else if (event.status === "ended") {
-                this.markEnded();
+                this.markEnded(meta);
             }
             else if (event.status === "error") {
                 const error = makeError("SESSION_ERROR", "session entered error status", { sessionId: this.sessionId });
-                this.rejectPendingSend(error);
-                this.emitError(error);
+                this.emitError(error, meta);
+                this.rejectActivePending(error);
             }
             return;
         }
         if (event.type === "tool_call") {
-            this.setStatus("waiting_tool_result");
-            this.handleToolCall(event);
+            const turn = this.requireActiveTurn("tool_call", meta);
+            if (!turn)
+                return;
+            this.setStatus("waiting_tool_result", meta);
+            this.handleToolCall(event, meta, turn);
             return;
         }
         if (event.type === "done") {
-            this.setStatus("idle");
-            this.resolvePendingSend();
+            this.setStatus("idle", meta);
+            this.resolveActivePending();
             return;
         }
         if (event.type === "error") {
-            this.setStatus("error");
+            this.setStatus("error", meta);
             const error = normalizeError(event.error, "SESSION_ERROR", "session error");
-            this.rejectPendingSend(error);
-            this.emitError(error);
+            this.emitError(error, meta);
+            this.rejectActivePending(error);
             return;
         }
         if (event.type === "ended") {
-            this.markEnded();
+            this.markEnded(meta);
         }
     }
-    async handleToolCall(event) {
+    replaceInlineToolHandlers(handlers) {
+        this.inlineToolHandlers = new Map(handlers);
+    }
+    async handleToolCall(event, meta, turn) {
         let result;
-        if (!this.toolHandler) {
-            result = {
-                error: makeError("TOOL_HANDLER_NOT_FOUND", `No tool handler registered for ${event.tool}`, {
-                    tool: event.tool,
-                }),
-            };
+        const namedHandler = this.namedToolHandlers.get(event.tool);
+        const inlineHandler = this.inlineToolHandlers.get(event.tool);
+        if (namedHandler) {
+            try {
+                result = await namedHandler(event.args, this.createToolCallContext(event, meta, turn));
+            }
+            catch (err) {
+                result = {
+                    error: normalizeError(err, "TOOL_HANDLER_ERROR", "Tool handler failed"),
+                };
+            }
         }
-        else {
+        else if (inlineHandler) {
             try {
-                result = await this.toolHandler(event.tool, event.args);
+                result = await inlineHandler(event.args, this.createToolCallContext(event, meta, turn));
             }
             catch (err) {
                 result = {
@@ -411,6 +599,23 @@ export class PedelecSession {
                 };
             }
         }
+        else if (this.genericToolHandler) {
+            try {
+                result = await this.genericToolHandler(event.tool, event.args, this.createToolCallContext(event, meta, turn));
+            }
+            catch (err) {
+                result = {
+                    error: normalizeError(err, "TOOL_HANDLER_ERROR", "Tool handler failed"),
+                };
+            }
+        }
+        else {
+            result = {
+                error: makeError("TOOL_HANDLER_NOT_FOUND", `No tool handler registered for ${event.tool}`, {
+                    tool: event.tool,
+                }),
+            };
+        }
         try {
             await this.client.request("submit_tool_result", {
                 sessionId: this.sessionId,
@@ -419,45 +624,152 @@ export class PedelecSession {
             });
         }
         catch (err) {
-            this.emitError(normalizeError(err, "SUBMIT_TOOL_RESULT_FAILED", "submit_tool_result failed"));
+            this.emitError(normalizeError(err, "SUBMIT_TOOL_RESULT_FAILED", "submit_tool_result failed"), {
+                source: "sdk",
+            });
         }
     }
     resolvePendingSend() {
         const pending = this.pendingSend;
         this.pendingSend = null;
         pending?.resolve();
+        this.finishActiveTurn();
+    }
+    resolvePendingPrepare() {
+        const pending = this.pendingPrepare;
+        this.pendingPrepare = null;
+        pending?.resolve();
+        this.finishActiveTurn();
+    }
+    resolveActivePending() {
+        if (this.activeTurn?.kind === "prepare") {
+            this.resolvePendingPrepare();
+        }
+        else {
+            this.resolvePendingSend();
+        }
     }
     rejectPendingSend(error) {
         const pending = this.pendingSend;
         this.pendingSend = null;
         pending?.reject(error);
+        this.finishActiveTurn();
+    }
+    rejectPendingPrepare(error) {
+        const pending = this.pendingPrepare;
+        this.pendingPrepare = null;
+        pending?.reject(error);
+        this.finishActiveTurn();
+    }
+    rejectActivePending(error) {
+        if (this.activeTurn?.kind === "prepare") {
+            this.rejectPendingPrepare(error);
+        }
+        else {
+            this.rejectPendingSend(error);
+        }
     }
     clearPendingSend() {
         this.pendingSend = null;
     }
-    markEnded() {
+    clearPendingPrepare() {
+        this.pendingPrepare = null;
+    }
+    markEnded(meta = { source: "sdk" }) {
         const wasEnded = this.status === "ended";
-        this.setStatus("ended");
-        this.rejectPendingSend(makeError("SESSION_ENDED", "session has ended", { sessionId: this.sessionId }));
+        this.setStatus("ended", meta);
         if (!wasEnded) {
             for (const handler of this.endedHandlers) {
-                handler();
+                handler(this.createEndedContext(meta));
             }
         }
+        this.rejectPendingSend(makeError("SESSION_ENDED", "session has ended", { sessionId: this.sessionId }));
+        this.rejectPendingPrepare(makeError("SESSION_ENDED", "session has ended", { sessionId: this.sessionId }));
+        this.finishActiveTurn();
     }
-    emitError(error) {
+    emitError(error, meta = { source: "sdk" }) {
         for (const handler of this.errorHandlers) {
-            handler(error);
+            handler(error, this.createErrorContext(meta));
         }
     }
-    setStatus(status) {
+    setStatus(status, meta = { source: "sdk" }) {
         if (this.status === status)
             return;
+        const previousStatus = this.status;
         this.status = status;
         for (const handler of this.statusHandlers) {
-            handler(status);
+            handler(status, this.createStatusContext(status, previousStatus, meta));
+        }
+    }
+    requireActiveTurn(type, meta) {
+        if (this.activeTurn)
+            return this.activeTurn;
+        this.emitError(makeError("SDK_PROTOCOL_ERROR", `${type} event was received without an active turn`, {
+            sessionId: this.sessionId,
+        }), { source: "sdk", eventReceivedAt: meta.eventReceivedAt });
+        return null;
+    }
+    finishActiveTurn(turn = this.activeTurn) {
+        if (!turn || !this.activeTurn)
+            return;
+        if (this.activeTurn.turnId === turn.turnId) {
+            this.activeTurn = null;
         }
     }
+    createBaseContext(meta, turn = this.activeTurn) {
+        return {
+            sessionId: this.sessionId,
+            provider: this.provider,
+            model: this.model,
+            sessionCreatedAt: this.sessionCreatedAt,
+            ...(meta.eventReceivedAt === undefined ? {} : { eventReceivedAt: meta.eventReceivedAt }),
+            eventEmittedAt: Date.now(),
+            ...(turn ? { turnId: turn.turnId, turnStartedAt: turn.turnStartedAt, turnKind: turn.kind } : {}),
+            source: meta.source,
+        };
+    }
+    createChatContext(meta, turn) {
+        return {
+            ...this.createBaseContext(meta, turn),
+            type: "chat_delta",
+            turnId: turn.turnId,
+            turnStartedAt: turn.turnStartedAt,
+            eventReceivedAt: meta.eventReceivedAt ?? Date.now(),
+            source: "core",
+        };
+    }
+    createToolCallContext(event, meta, turn) {
+        return {
+            ...this.createBaseContext(meta, turn),
+            type: "tool_call",
+            toolRequestId: event.toolRequestId,
+            tool: event.tool,
+            turnId: turn.turnId,
+            turnStartedAt: turn.turnStartedAt,
+            eventReceivedAt: meta.eventReceivedAt ?? Date.now(),
+            source: "core",
+        };
+    }
+    createStatusContext(status, previousStatus, meta) {
+        return {
+            ...this.createBaseContext(meta),
+            type: meta.source === "core" ? "status_changed" : "sdk_status_changed",
+            status,
+            previousStatus,
+        };
+    }
+    createErrorContext(meta) {
+        return {
+            ...this.createBaseContext(meta),
+            type: meta.source === "core" ? "error" : "sdk_error",
+        };
+    }
+    createEndedContext(meta) {
+        return {
+            ...this.createBaseContext(meta),
+            type: meta.source === "core" ? "ended" : "sdk_ended",
+        };
+    }
 }
 function isSessionEvent(message) {
     return (message.type === "chat_delta" ||
@@ -470,14 +782,23 @@ function isSessionEvent(message) {
 function isSettings(value) {
     if (!value || typeof value !== "object")
         return false;
+    if (Array.isArray(value))
+        return false;
     const settings = value;
+    const defaultModels = settings.defaultModels;
+    if (settings.defaultModel !== undefined)
+        return false;
+    if (!defaultModels || typeof defaultModels !== "object" || Array.isArray(defaultModels)) {
+        return false;
+    }
     return ((settings.defaultProvider === null ||
         settings.defaultProvider === "codex" ||
         settings.defaultProvider === "gemini" ||
         settings.defaultProvider === "opencode" ||
         settings.defaultProvider === "cursor" ||
-        settings.defaultProvider === "claude") &&
-        (settings.defaultModel === null || typeof settings.defaultModel === "string"));
+        settings.defaultProvider === "claude" ||
+        settings.defaultProvider === "ollama") &&
+        Object.entries(defaultModels).every(([provider, model]) => isProviderCode(provider) && typeof model === "string"));
 }
 function isApprovalStatus(value) {
     if (!value || typeof value !== "object")
@@ -492,7 +813,8 @@ function isProviderCode(value) {
         value === "gemini" ||
         value === "opencode" ||
         value === "cursor" ||
-        value === "claude");
+        value === "claude" ||
+        value === "ollama");
 }
 function makeError(code, message, details) {
     return details === undefined ? { code, message } : { code, message, details };
@@ -503,6 +825,16 @@ function createChannelId() {
         : Math.random().toString(36).slice(2);
     return `pedelec_${Date.now()}_${random}`;
 }
+function createTurn(kind = "user") {
+    const random = typeof crypto !== "undefined" && "randomUUID" in crypto
+        ? crypto.randomUUID()
+        : Math.random().toString(36).slice(2);
+    return {
+        turnId: `turn_${Date.now()}_${random}`,
+        turnStartedAt: Date.now(),
+        kind,
+    };
+}
 function getCurrentOrigin(pageWindow) {
     const origin = pageWindow?.location?.origin;
     return typeof origin === "string" && origin ? origin : null;