@lapis-notes/ai 0.1.1 → 0.1.5

package/dist/settings/ai-settings.d.ts

@@ -1,5 +1,5 @@
 import type { AiThinkingLevel } from "../core/types";
-import { type AcpAgentId } from "./acp-agents";
+import { type AcpAgentId, type ProcessorAgentId } from "./acp-agents";
 export type AppToolEnablementOwner = {
     pluginId: string;
     source: "core" | "community" | "official" | "system";
@@ -9,7 +9,7 @@ export type AppToolEnablementRef = {
     owner: AppToolEnablementOwner;
 };
 export type AiPluginSettings = {
-    defaultRuntime: "auto" | "acp" | "codex-native" | "fake";
+    defaultRuntime: "auto" | "acp" | "codex-native" | "opencode-native" | "fake";
     acpAgent: AcpAgentId;
     defaultModels: Record<AcpAgentId, string>;
     /** Active-agent compatibility alias. Persisted model ownership lives in defaultModels. */
@@ -18,11 +18,11 @@ export type AiPluginSettings = {
     memoryAutomaticRecall: boolean;
     memoryConsolidationEnabled: boolean;
     memoryConsolidationRuntime: "acp" | "codex-native";
-    memoryConsolidationAgent: AcpAgentId;
+    memoryConsolidationAgent: ProcessorAgentId;
     memoryConsolidationModel: string;
     handoffSummariesEnabled: boolean;
     handoffSummaryRuntime: "acp" | "codex-native";
-    handoffSummaryAgent: AcpAgentId;
+    handoffSummaryAgent: ProcessorAgentId;
     handoffSummaryModel: string;
     appToolsEnabled: boolean;
     disabledAppToolNames: string[];

package/dist/settings/ai-settings.js

@@ -1,10 +1,11 @@
-import { DEFAULT_ACP_AGENT, normalizeAcpAgent, } from "./acp-agents";
+import { DEFAULT_ACP_AGENT, normalizeAcpAgent, normalizeProcessorAgent, } from "./acp-agents";
 export const DEFAULT_AI_SETTINGS = {
     defaultRuntime: "auto",
     acpAgent: DEFAULT_ACP_AGENT,
     defaultModels: {
         codex: "gpt-5.6-sol",
         cursor: "",
+        opencode: "",
     },
     defaultModel: "gpt-5.6-sol",
     thinking: "medium",
@@ -113,6 +114,7 @@ export function mergeAiSettings(value, registeredTools) {
             legacyModel ||
             DEFAULT_AI_SETTINGS.defaultModels.codex,
         cursor: storedModels?.cursor?.trim() || "",
+        opencode: storedModels?.opencode?.trim() || "",
     };
     const thinking = value?.thinking;
     const merged = {
@@ -128,12 +130,12 @@ export function mergeAiSettings(value, registeredTools) {
         memoryConsolidationRuntime: value?.memoryConsolidationRuntime === "codex-native"
             ? "codex-native"
             : "acp",
-        memoryConsolidationAgent: normalizeAcpAgent(value?.memoryConsolidationAgent),
+        memoryConsolidationAgent: normalizeProcessorAgent(value?.memoryConsolidationAgent),
         memoryConsolidationModel: value?.memoryConsolidationModel?.trim() ||
             DEFAULT_AI_SETTINGS.memoryConsolidationModel,
         handoffSummariesEnabled: value?.handoffSummariesEnabled === true,
         handoffSummaryRuntime: value?.handoffSummaryRuntime === "codex-native" ? "codex-native" : "acp",
-        handoffSummaryAgent: normalizeAcpAgent(value?.handoffSummaryAgent),
+        handoffSummaryAgent: normalizeProcessorAgent(value?.handoffSummaryAgent),
         handoffSummaryModel: value?.handoffSummaryModel?.trim() ||
             DEFAULT_AI_SETTINGS.handoffSummaryModel,
         appToolsEnabled: value?.appToolsEnabled !== false,

package/dist/settings/register-ai-settings.js

@@ -1,5 +1,6 @@
+import { modelCatalogProviderId } from "../providers/model-provider";
 import { getWorkspaceHostBinding } from "@lapis-notes/api/workspace-host";
-import { ACP_AGENT_IDS, normalizeAcpAgent, } from "./acp-agents";
+import { ACP_AGENT_IDS, PROCESSOR_AGENT_IDS, normalizeAcpAgent, normalizeProcessorAgent, } from "./acp-agents";
 import { APP_TOOL_SETTING_PREFIX, DEFAULT_AI_SETTINGS, applyAppToolEnablement, migrateLegacyCommunityToolOptIns, } from "./ai-settings";
 import { listAppToolSettingRows, registeredAppToolRefs, } from "./app-tool-setting-rows";
 const FIELD_IDS = {
@@ -25,7 +26,7 @@ export function registerAiSettings(plugin) {
         return;
     const controller = binding.controller;
     const settings = plugin.getSettings();
-    const modelSourceId = (provider) => `ai.models.${provider}`;
+    const modelSourceId = (provider, runtime) => `ai.models.${modelCatalogProviderId(provider, runtime)}`;
     const persistLegacyToolMigration = () => {
         const current = plugin.getSettings();
         const migrated = migrateLegacyCommunityToolOptIns(current, registeredAppToolRefs(plugin.app));
@@ -40,14 +41,18 @@ export function registerAiSettings(plugin) {
             enabledCommunityToolPluginIds: migrated.enabledCommunityToolPluginIds,
         });
     };
-    for (const provider of ACP_AGENT_IDS) {
+    for (const { provider, runtime } of [
+        ...ACP_AGENT_IDS.map((provider) => ({ provider, runtime: "acp" })),
+        { provider: "codex", runtime: "codex-native" },
+        { provider: "opencode", runtime: "opencode-native" },
+    ]) {
         const dispose = controller.configuration.optionSources.register({
-            id: modelSourceId(provider),
+            id: modelSourceId(provider, runtime),
             load: async () => {
                 const current = plugin.getSettings();
                 const saved = current.defaultModels[provider];
                 try {
-                    const models = await plugin.models.listModels(provider);
+                    const models = await plugin.models.listModels(provider, runtime);
                     if (models.length === 0) {
                         return saved
                             ? [
@@ -112,6 +117,7 @@ export function registerAiSettings(plugin) {
                     { value: "auto", label: "Automatic" },
                     { value: "acp", label: "ACP" },
                     { value: "codex-native", label: "Codex native" },
+                    { value: "opencode-native", label: "OpenCode native" },
                     { value: "fake", label: "Fake (tests)" },
                 ],
             },
@@ -123,7 +129,11 @@ export function registerAiSettings(plugin) {
                 default: DEFAULT_AI_SETTINGS.acpAgent,
                 options: ACP_AGENT_IDS.map((value) => ({
                     value,
-                    label: value === "cursor" ? "Cursor" : "Codex",
+                    label: value === "cursor"
+                        ? "Cursor"
+                        : value === "opencode"
+                            ? "OpenCode"
+                            : "Codex",
                 })),
             },
             {
@@ -132,7 +142,7 @@ export function registerAiSettings(plugin) {
                 title: "Default model",
                 description: "Model reported by the selected agent provider and sent on the next request.",
                 default: current.defaultModel,
-                optionsSource: modelSourceId(current.acpAgent),
+                optionsSource: modelSourceId(current.acpAgent, current.defaultRuntime),
                 allowUnknownOptions: false,
             },
             {
@@ -179,7 +189,7 @@ export function registerAiSettings(plugin) {
                 title: "Memory processor agent",
                 description: "Pinned independently from the interactive chat agent.",
                 default: DEFAULT_AI_SETTINGS.memoryConsolidationAgent,
-                options: ACP_AGENT_IDS.map((value) => ({
+                options: PROCESSOR_AGENT_IDS.map((value) => ({
                     value,
                     label: value === "cursor" ? "Cursor" : "Codex",
                 })),
@@ -215,7 +225,7 @@ export function registerAiSettings(plugin) {
                 title: "Handoff summary agent",
                 description: "Pinned independently from the interactive chat agent.",
                 default: DEFAULT_AI_SETTINGS.handoffSummaryAgent,
-                options: ACP_AGENT_IDS.map((value) => ({
+                options: PROCESSOR_AGENT_IDS.map((value) => ({
                     value,
                     label: value === "cursor" ? "Cursor" : "Codex",
                 })),
@@ -305,9 +315,12 @@ export function registerAiSettings(plugin) {
             return;
         }
         if (event.id === FIELD_IDS.defaultRuntime) {
-            void plugin.updateSettings({
-                defaultRuntime: values[FIELD_IDS.defaultRuntime],
-            });
+            void (async () => {
+                await plugin.updateSettings({
+                    defaultRuntime: values[FIELD_IDS.defaultRuntime],
+                });
+                refreshSection(plugin.getSettings());
+            })();
             return;
         }
         if (event.id === FIELD_IDS.thinking) {
@@ -338,7 +351,7 @@ export function registerAiSettings(plugin) {
         }
         if (event.id === FIELD_IDS.memoryConsolidationAgent) {
             void plugin.updateSettings({
-                memoryConsolidationAgent: normalizeAcpAgent(values[FIELD_IDS.memoryConsolidationAgent]),
+                memoryConsolidationAgent: normalizeProcessorAgent(values[FIELD_IDS.memoryConsolidationAgent]),
             });
             return;
         }
@@ -364,7 +377,7 @@ export function registerAiSettings(plugin) {
         }
         if (event.id === FIELD_IDS.handoffSummaryAgent) {
             void plugin.updateSettings({
-                handoffSummaryAgent: normalizeAcpAgent(values[FIELD_IDS.handoffSummaryAgent]),
+                handoffSummaryAgent: normalizeProcessorAgent(values[FIELD_IDS.handoffSummaryAgent]),
             });
             return;
         }

package/dist/tools/app-tool-host.d.ts

@@ -1,7 +1,26 @@
 import { type AppToolApprovalDetails, type AppToolRegistry, type AppToolResult, type RegisteredAppTool } from "@lapis-notes/api/agent-tools";
 import type { AppToolSessionDescriptor, ApprovalOptionKind, ApprovalRequest } from "../core/types";
 import { type AiPluginSettings } from "../settings/ai-settings";
-export type AppToolExecutionErrorCode = "approval_denied" | "cancelled" | "execution_failed" | "invalid_arguments" | "invalid_result" | "invalid_tool_schema" | "timed_out" | "tool_unavailable";
+export type AppToolExecutionErrorCode = "approval_denied" | "cancelled" | "capture_unavailable" | "execution_failed" | "invalid_arguments" | "invalid_result" | "invalid_tool_schema" | "timed_out" | "tool_unavailable";
+export interface AppToolCapture {
+    begin(input: {
+        caller: string;
+        requestKey: string;
+        workspaceId: string;
+        captureMode: "cooperative" | "observed";
+        intent: string;
+        toolName: string;
+    }): Promise<{
+        spanId: string;
+    }>;
+    finish(input: {
+        caller: string;
+        requestKey: string;
+        workspaceId: string;
+        spanId: string;
+        outcome: "succeeded" | "failed" | "unknown";
+    }): Promise<void>;
+}
 export declare class AppToolExecutionError extends Error {
     readonly code: AppToolExecutionErrorCode;
     constructor(code: AppToolExecutionErrorCode, message: string);
@@ -34,8 +53,9 @@ export declare class AppToolHost {
     private readonly registry;
     private readonly settings;
     private readonly timeoutMs;
+    private readonly capture?;
     readonly approvals: AppToolApprovalBroker;
-    constructor(registry: AppToolRegistry, settings: () => AppToolPolicySettings, timeoutMs?: number);
+    constructor(registry: AppToolRegistry, settings: () => AppToolPolicySettings, timeoutMs?: number, capture?: AppToolCapture | undefined);
     createSession(input: CreateAppToolSessionInput): AppToolSessionDescriptor;
     getSession(agentBindingId: string): AppToolSessionDescriptor | undefined;
     invoke(agentBindingId: string, call: AppToolCall, signal?: AbortSignal): Promise<AppToolResult>;

package/dist/tools/app-tool-host.js

@@ -102,6 +102,7 @@ export class AppToolHost {
     registry;
     settings;
     timeoutMs;
+    capture;
     approvals = new AppToolApprovalBroker();
     #ajv = new Ajv({ allErrors: true, strict: false });
     #sessions = new Map();
@@ -109,10 +110,11 @@ export class AppToolHost {
     #validators = new Map();
     #activeInvocations = new Map();
     #registryChangeRef;
-    constructor(registry, settings, timeoutMs = DEFAULT_TIMEOUT_MS) {
+    constructor(registry, settings, timeoutMs = DEFAULT_TIMEOUT_MS, capture) {
         this.registry = registry;
         this.settings = settings;
         this.timeoutMs = timeoutMs;
+        this.capture = capture;
         this.#registryChangeRef = registry.on("changed", (change) => {
             if (change.reason !== "unregistered")
                 return;
@@ -190,9 +192,54 @@ export class AppToolHost {
             if (grantForSession) {
                 this.#grants.add(grantKey(session.descriptor, registered));
             }
-            const result = await raceWithAbort(registered.tool.execute(call.input, context), invocation.signal);
-            this.validateResult(registered, result);
-            return result;
+            let spanId;
+            if (this.capture && registered.tool.effect !== "read") {
+                try {
+                    const span = await this.capture.begin({
+                        caller: "app-tool-host",
+                        requestKey: call.toolCallId,
+                        workspaceId: session.descriptor.scopeDir,
+                        captureMode: "cooperative",
+                        intent: "tool",
+                        toolName: call.name,
+                    });
+                    spanId = span.spanId;
+                }
+                catch {
+                    throw new AppToolExecutionError("capture_unavailable", `Checkpoint capture is unavailable for app tool: ${call.name}`);
+                }
+            }
+            try {
+                const result = await raceWithAbort(registered.tool.execute(call.input, context), invocation.signal);
+                this.validateResult(registered, result);
+                if (spanId && this.capture) {
+                    await this.capture.finish({
+                        caller: "app-tool-host",
+                        requestKey: `${call.toolCallId}:finish`,
+                        workspaceId: session.descriptor.scopeDir,
+                        spanId,
+                        outcome: "succeeded",
+                    });
+                }
+                return result;
+            }
+            catch (error) {
+                if (spanId && this.capture) {
+                    try {
+                        await this.capture.finish({
+                            caller: "app-tool-host",
+                            requestKey: `${call.toolCallId}:failed`,
+                            workspaceId: session.descriptor.scopeDir,
+                            spanId,
+                            outcome: "failed",
+                        });
+                    }
+                    catch {
+                        // Preserve the original tool error.
+                    }
+                }
+                throw error;
+            }
         }
         catch (error) {
             if (error instanceof AppToolExecutionError) {

package/dist/tools/desktop-app-tool-bridge.d.ts

@@ -1,4 +1,5 @@
 import type { AgentEvent, AppToolSessionDescriptor, ApprovalOptionKind } from "../core/types";
+import type { ControllerConnection } from "../host/controller-connection";
 import { AppToolHost, type CreateAppToolSessionInput } from "./app-tool-host";
 export type AppToolBridgeEvent = {
     bindingId: string;
@@ -11,10 +12,12 @@ export interface AppToolBridgeCoordinator {
     subscribe(listener: (event: AppToolBridgeEvent) => void): () => void;
     close(): Promise<void>;
 }
+/** App authorization stays here; the shared SDK owns transport and tool receipts. */
 export declare class DesktopAppToolBridge implements AppToolBridgeCoordinator {
     #private;
     private readonly host;
-    constructor(host: AppToolHost);
+    private readonly connection;
+    constructor(host: AppToolHost, connection: () => Promise<ControllerConnection>);
     prepare(input: CreateAppToolSessionInput): Promise<AppToolSessionDescriptor>;
     respondToApproval(requestId: string, decision: ApprovalOptionKind): boolean;
     subscribe(listener: (event: AppToolBridgeEvent) => void): () => void;

package/dist/tools/desktop-app-tool-bridge.js

@@ -1,78 +1,127 @@
-import { getNativeDesktopBridge, getNativeDesktopCapability, } from "@lapis-notes/api/desktop-native";
 import { AppToolExecutionError, AppToolHost, } from "./app-tool-host";
-const APP_TOOL_MCP_SERVER_NAME = "lapis-tools";
-const SUPPORTED_APP_TOOL_TRANSPORTS = new Set(["stdio-mcp", "http-mcp"]);
+/** App authorization stays here; the shared SDK owns transport and tool receipts. */
 export class DesktopAppToolBridge {
     host;
+    connection;
     #records = new Map();
     #listeners = new Set();
     #unsubscribeApprovals;
-    #subscribedBridge = null;
-    #unsubscribeCall;
-    #unsubscribeCancel;
-    constructor(host) {
+    constructor(host, connection) {
         this.host = host;
+        this.connection = connection;
         this.#unsubscribeApprovals = host.approvals.subscribe((request, bindingId) => {
             const record = this.#records.get(bindingId);
             const active = record ? [...record.calls.values()].at(-1) : undefined;
             this.#emit(bindingId, {
                 type: "permission.request",
                 request,
-                ...(record && active
-                    ? { source: nextSource(record, active) }
-                    : {}),
+                ...(record && active ? { source: nextSource(record, active) } : {}),
             });
         });
     }
     async prepare(input) {
-        if (this.#records.has(input.agentBindingId)) {
+        if (this.#records.has(input.agentBindingId))
             throw new Error(`App tool bridge already exists: ${input.agentBindingId}`);
-        }
-        const bridge = getNativeDesktopBridge();
-        const hostCapable = supportsAppTools();
-        const runtimeCapable = input.runtimeSupportsAppTools;
-        const descriptor = this.host.createSession({
-            ...input,
-            runtimeSupportsAppTools: runtimeCapable && hostCapable,
-        });
+        const descriptor = this.host.createSession(input);
         const record = {
             bindingId: input.agentBindingId,
+            bridgeId: `lapis.tools.${input.agentBindingId}`,
             calls: new Map(),
         };
         this.#records.set(input.agentBindingId, record);
-        if (!runtimeCapable) {
-            return withStatus(descriptor, "runtime-unavailable", "The selected agent runtime does not support application tools.");
-        }
-        if (!hostCapable || !bridge?.onAgentToolCall || !bridge.onAgentToolCancel) {
-            return withStatus(descriptor, "host-upgrade-required", "Application tools require an agent host with protocol v3 support.");
-        }
-        if (descriptor.tools.length === 0) {
-            return withStatus(descriptor, "disabled");
-        }
-        this.#subscribeToBridge(bridge);
+        if (!input.runtimeSupportsAppTools)
+            return Object.freeze({
+                ...descriptor,
+                status: "runtime-unavailable",
+                unavailableReason: "The selected runtime does not support application tools.",
+            });
+        if (!descriptor.tools.length)
+            return Object.freeze({ ...descriptor, status: "disabled" });
         try {
-            const opened = await bridge.invoke("desktop_agent_tools_open", {
-                bindingId: descriptor.agentBindingId,
-                conversationId: descriptor.conversationId,
-                descriptors: descriptor.tools.map((tool) => ({
+            const { client } = await this.connection();
+            record.unregister = await client.registerEndpoint({
+                id: record.bridgeId,
+                tools: descriptor.tools.map((tool) => ({
                     name: tool.name,
                     description: tool.description,
                     inputSchema: tool.inputSchema,
-                    outputSchema: tool.outputSchema,
-                    effect: tool.effect,
+                    effect: tool.effect === "read" ? "read" : "write",
                 })),
+                handle: async (request, signal) => {
+                    if (request.operation !== "tool.execute" ||
+                        this.#records.get(record.bindingId) !== record)
+                        throw new Error("Application tool binding is unavailable.");
+                    const call = request.payload;
+                    const active = {
+                        abort: new AbortController(),
+                        runId: `app-tool-${call.invocationId}`,
+                        sequence: 0,
+                    };
+                    const abort = () => active.abort.abort();
+                    if (signal.aborted)
+                        abort();
+                    signal.addEventListener("abort", abort, { once: true });
+                    record.calls.set(call.invocationId, active);
+                    this.#emit(record.bindingId, {
+                        type: "tool.start",
+                        id: call.invocationId,
+                        name: call.name,
+                        server: "lapis-tools",
+                        input: call.arguments,
+                        source: nextSource(record, active),
+                    });
+                    try {
+                        const result = await this.host.invoke(record.bindingId, {
+                            runId: active.runId,
+                            toolCallId: call.invocationId,
+                            name: call.name,
+                            input: call.arguments,
+                        }, active.abort.signal);
+                        this.#emit(record.bindingId, {
+                            type: "tool.end",
+                            id: call.invocationId,
+                            name: call.name,
+                            server: "lapis-tools",
+                            output: result,
+                            source: nextSource(record, active),
+                        });
+                        return result;
+                    }
+                    catch (error) {
+                        const normalized = error instanceof AppToolExecutionError
+                            ? { code: error.code, message: error.message }
+                            : {
+                                code: "execution_failed",
+                                message: "Application tool execution failed.",
+                            };
+                        this.#emit(record.bindingId, {
+                            type: "tool.end",
+                            id: call.invocationId,
+                            name: call.name,
+                            server: "lapis-tools",
+                            error: normalized,
+                            source: nextSource(record, active),
+                        });
+                        return {
+                            content: [{ type: "text", text: normalized.message }],
+                            isError: true,
+                        };
+                    }
+                    finally {
+                        signal.removeEventListener("abort", abort);
+                        record.calls.delete(call.invocationId);
+                    }
+                },
             });
-            record.bridge = bridge;
-            record.bridgeId = opened.bridgeId;
             return Object.freeze({
                 ...descriptor,
-                bridgeId: opened.bridgeId,
+                bridgeId: record.bridgeId,
                 status: "available",
             });
         }
         catch (error) {
-            this.#records.delete(input.agentBindingId);
-            this.host.closeBinding(input.agentBindingId);
+            this.#records.delete(record.bindingId);
+            this.host.closeBinding(record.bindingId);
             throw error;
         }
     }
@@ -88,136 +137,24 @@ export class DesktopAppToolBridge {
         this.#records.delete(bindingId);
         for (const call of record?.calls.values() ?? [])
             call.abort.abort();
-        record?.calls.clear();
         this.host.closeBinding(bindingId);
-        if (record?.bridge && record.bridgeId) {
-            await record.bridge
-                .invoke("desktop_agent_tools_close", { bridgeId: record.bridgeId })
-                .catch(() => undefined);
-        }
+        await record?.unregister?.().catch(() => undefined);
     }
     async close() {
-        for (const bindingId of [...this.#records.keys()]) {
-            await this.closeBinding(bindingId);
-        }
+        for (const id of [...this.#records.keys()])
+            await this.closeBinding(id);
         this.#unsubscribeApprovals();
-        this.#unsubscribeCall?.();
-        this.#unsubscribeCancel?.();
         this.#listeners.clear();
-        this.#subscribedBridge = null;
-    }
-    #subscribeToBridge(bridge) {
-        if (this.#subscribedBridge === bridge)
-            return;
-        this.#unsubscribeCall?.();
-        this.#unsubscribeCancel?.();
-        this.#subscribedBridge = bridge;
-        this.#unsubscribeCall = bridge.onAgentToolCall?.((call) => {
-            void this.#handleCall(call);
-        });
-        this.#unsubscribeCancel = bridge.onAgentToolCancel?.((cancel) => {
-            this.#handleCancel(cancel);
-        });
-    }
-    async #handleCall(call) {
-        const record = this.#records.get(call.bindingId);
-        if (!record || record.bridgeId !== call.bridgeId || !record.bridge)
-            return;
-        if (record.calls.has(call.callId))
-            return;
-        const active = {
-            abort: new AbortController(),
-            runId: `app-tool-${call.callId}`,
-            sequence: 0,
-        };
-        record.calls.set(call.callId, active);
-        this.#emit(call.bindingId, {
-            type: "tool.start",
-            id: call.callId,
-            name: call.name,
-            server: APP_TOOL_MCP_SERVER_NAME,
-            input: call.input,
-            source: nextSource(record, active),
-        });
-        try {
-            const result = await this.host.invoke(call.bindingId, {
-                runId: active.runId,
-                toolCallId: call.callId,
-                name: call.name,
-                input: call.input,
-            }, active.abort.signal);
-            await record.bridge.invoke("desktop_agent_tools_respond", {
-                bridgeId: call.bridgeId,
-                callId: call.callId,
-                result,
-            });
-            this.#emit(call.bindingId, {
-                type: "tool.end",
-                id: call.callId,
-                name: call.name,
-                server: APP_TOOL_MCP_SERVER_NAME,
-                output: result,
-                source: nextSource(record, active),
-            });
-        }
-        catch (error) {
-            const normalized = normalizeExecutionError(error);
-            await record.bridge
-                .invoke("desktop_agent_tools_respond", {
-                bridgeId: call.bridgeId,
-                callId: call.callId,
-                error: normalized,
-            })
-                .catch(() => undefined);
-            this.#emit(call.bindingId, {
-                type: "tool.end",
-                id: call.callId,
-                name: call.name,
-                server: APP_TOOL_MCP_SERVER_NAME,
-                error: normalized,
-                source: nextSource(record, active),
-            });
-        }
-        finally {
-            record.calls.delete(call.callId);
-        }
-    }
-    #handleCancel(cancel) {
-        const record = this.#records.get(cancel.bindingId);
-        if (!record || record.bridgeId !== cancel.bridgeId)
-            return;
-        record.calls.get(cancel.callId)?.abort.abort();
     }
     #emit(bindingId, event) {
         for (const listener of this.#listeners)
             listener({ bindingId, event });
     }
 }
-function supportsAppTools() {
-    const capability = getNativeDesktopCapability("agent-runtime");
-    const protocolVersion = Number(capability?.details?.protocolVersion ?? 0);
-    const transport = String(capability?.details?.appTools ?? "");
-    return (capability?.status === "available" &&
-        protocolVersion >= 3 &&
-        SUPPORTED_APP_TOOL_TRANSPORTS.has(transport));
-}
-function withStatus(descriptor, status, unavailableReason) {
-    return Object.freeze({ ...descriptor, status, unavailableReason });
-}
 function nextSource(record, active) {
-    active.sequence += 1;
     return {
-        sessionId: record.bridgeId ?? record.bindingId,
+        sessionId: record.bridgeId,
         runId: active.runId,
-        sequence: active.sequence,
-    };
-}
-function normalizeExecutionError(error) {
-    if (error instanceof AppToolExecutionError) {
-        return { code: error.code, message: error.message };
-    }
-    return {
-        code: "execution_failed",
-        message: "Application tool execution failed.",
+        sequence: ++active.sequence,
     };
 }

package/manifest.json

@@ -1,10 +1,12 @@
 {
   "id": "ai",
   "name": "AI",
-  "version": "0.1.1",
+  "version": "0.1.5",
   "minAppVersion": "0.1.0",
   "description": "Provider-agnostic agent chat with ACP and optional native runtimes.",
   "author": "Lapis Notes",
+  "authorAvatarUrl": "https://www.gravatar.com/avatar/1df68d9ff087b0dd72fd8626056fca7f?s=128&d=404",
+  "isDesktopOnly": false,
   "lapis": {
     "manifestVersion": 1,
     "source": "official",
@@ -24,7 +26,23 @@
             "@lapis-notes/api/path",
             "@lapis-notes/api/vault",
             "@lapis-notes/api/workspace-host",
-            "@lapis-notes/markdown/embed"
+            "@lapis-notes/markdown/embed",
+            "@codemirror/autocomplete",
+            "@codemirror/commands",
+            "@codemirror/language",
+            "@codemirror/state",
+            "@codemirror/view",
+            "@lezer/common",
+            "@lezer/highlight",
+            "@lezer/lr",
+            "svelte/renderer/5.56.10",
+            "svelte/renderer/5.56.10/attachments",
+            "svelte/renderer/5.56.10/events",
+            "svelte/renderer/5.56.10/internal/client",
+            "svelte/renderer/5.56.10/internal/disclose-version",
+            "svelte/renderer/5.56.10/internal/flags/legacy",
+            "svelte/renderer/5.56.10/reactivity",
+            "svelte/renderer/5.56.10/store"
           ],
           "requiresReloadOnUpdate": false
         }