@lapis-notes/ai 0.1.0

package/dist/runtimes/acp/acp-runtime.js

@@ -0,0 +1,165 @@
+import { AsyncEventQueue } from "../../core/event-queue";
+import { ACP_APPROVAL_CAPABILITIES, projectAgentTurnPrompt, } from "../../core/types";
+import { mapAcpPermissionRequest, mapAcpRuntimeEvent, mapApprovalOptionToAcpDecision, } from "./acp-event-mapper";
+import { projectSkillActivationPrompt } from "../../skills/activation";
+export class AcpAgentSession {
+    id;
+    #backend;
+    #events = new AsyncEventQueue();
+    #pending = new Map();
+    #consume = null;
+    #activations;
+    constructor(backend, activations) {
+        this.id = backend.id;
+        this.#backend = backend;
+        this.#activations = activations;
+        this.#consume = this.#pump();
+    }
+    events() {
+        return this.#events;
+    }
+    async send(input, options) {
+        const projected = projectSkillActivationPrompt(projectAgentTurnPrompt(input, options?.contextBlocks), this.#activations);
+        this.#activations = undefined;
+        await this.#backend.prompt(projected);
+    }
+    configure(input) {
+        if (!this.#backend.configure) {
+            return Promise.resolve({
+                ...(input.model
+                    ? {
+                        model: {
+                            status: "unsupported",
+                            reason: "ACP backend configuration is unavailable.",
+                        },
+                    }
+                    : {}),
+                ...(input.thinking
+                    ? {
+                        thinking: {
+                            status: "unsupported",
+                            reason: "ACP backend configuration is unavailable.",
+                        },
+                    }
+                    : {}),
+            });
+        }
+        return this.#backend.configure(input);
+    }
+    async respondToApproval(requestId, optionId) {
+        const pending = this.#pending.get(requestId);
+        if (!pending)
+            throw new Error(`Unknown approval request: ${requestId}`);
+        this.#pending.delete(requestId);
+        pending.resolve(optionId);
+    }
+    async cancel() {
+        await this.#backend.cancel();
+    }
+    async detach() {
+        for (const [id, pending] of this.#pending) {
+            this.#pending.delete(id);
+            pending.reject(new Error("Session detached."));
+        }
+        if (this.#backend.detach)
+            await this.#backend.detach();
+        else
+            await this.#backend.close();
+        await this.#consume;
+        this.#events.close();
+    }
+    async close() {
+        for (const [id, pending] of this.#pending) {
+            this.#pending.delete(id);
+            pending.reject(new Error("Session closed."));
+        }
+        await this.#backend.close();
+        await this.#consume;
+        this.#events.close();
+    }
+    async handlePermissionRequest(request) {
+        const mapped = mapAcpPermissionRequest(request);
+        this.#events.push({
+            type: "permission.request",
+            request: mapped,
+            ...(request.__source ? { source: { ...request.__source } } : {}),
+        });
+        return new Promise((resolve, reject) => {
+            this.#pending.set(mapped.id, {
+                resolve: (optionId) => resolve(mapApprovalOptionToAcpDecision(optionId)),
+                reject,
+            });
+        });
+    }
+    async #pump() {
+        try {
+            for await (const event of this.#backend.events()) {
+                const mapped = mapAcpRuntimeEvent(event);
+                if (mapped)
+                    this.#events.push(mapped);
+            }
+        }
+        catch (error) {
+            this.#events.push({
+                type: "error",
+                error: error instanceof Error ? error : new Error(String(error)),
+            });
+        }
+    }
+}
+export class AcpAgentRuntime {
+    id = "acp";
+    #backend;
+    constructor(backend) {
+        this.#backend = backend;
+    }
+    capabilities() {
+        return {
+            sessions: true,
+            resume: typeof this.#backend.resume === "function",
+            cancel: true,
+            steer: false,
+            modelSelection: true,
+            nativeTools: true,
+            mcpTools: true,
+            approvals: ACP_APPROVAL_CAPABILITIES,
+        };
+    }
+    async supports(request) {
+        if (request.requirePolicyAmendments)
+            return false;
+        return this.#backend.available();
+    }
+    async start(request) {
+        let session;
+        const backend = await this.#backend.start({
+            request,
+            onPermissionRequest: (permission) => {
+                if (!session) {
+                    throw new Error("ACP session is not ready for approvals.");
+                }
+                return session.handlePermissionRequest(permission);
+            },
+        });
+        session = new AcpAgentSession(backend, request.skillActivations);
+        return session;
+    }
+    async resume(sessionId, request) {
+        if (!this.#backend.resume) {
+            throw new Error("ACP backend does not support resume.");
+        }
+        let session;
+        const backend = await this.#backend.resume({
+            sessionId,
+            request,
+            onPermissionRequest: (permission) => {
+                if (!session) {
+                    throw new Error("ACP session is not ready for approvals.");
+                }
+                return session.handlePermissionRequest(permission);
+            },
+        });
+        session = new AcpAgentSession(backend, request?.skillActivations);
+        return session;
+    }
+}

package/dist/runtimes/acp/desktop-acp-backend.d.ts

@@ -0,0 +1,16 @@
+import type { AgentRequest } from "../../core/types";
+import type { AcpBackendSession, AcpRuntimeBackend } from "./acp-runtime";
+import type { AcpPermissionDecision, AcpPermissionRequestLike } from "./acp-event-mapper";
+export declare class DesktopAcpRuntimeBackend implements AcpRuntimeBackend {
+    #private;
+    available(): Promise<boolean>;
+    start(input: {
+        request: AgentRequest;
+        onPermissionRequest(request: AcpPermissionRequestLike): Promise<AcpPermissionDecision>;
+    }): Promise<AcpBackendSession>;
+    resume(input: {
+        sessionId: string;
+        request?: Omit<AgentRequest, "prompt">;
+        onPermissionRequest(request: AcpPermissionRequestLike): Promise<AcpPermissionDecision>;
+    }): Promise<AcpBackendSession>;
+}

package/dist/runtimes/acp/desktop-acp-backend.js

@@ -0,0 +1,243 @@
+import { getNativeDesktopBridge, getNativeDesktopCapability, hasNativeDesktopCapability, } from "@lapis-notes/api/desktop-native";
+import { AsyncEventQueue } from "../../core/event-queue";
+const RUN_STATUS_POLL_MS = 1_000;
+const MAX_RUN_STATUS_FAILURES = 3;
+function isTerminalRuntimeEvent(event) {
+    const type = event.event.event?.type;
+    return (event.event.type === "closed" ||
+        type === "done" ||
+        type === "completed" ||
+        type === "error");
+}
+export class DesktopAcpRuntimeBackend {
+    async available() {
+        return hasNativeDesktopCapability("agent-runtime");
+    }
+    async start(input) {
+        return this.#open(input.request, input.onPermissionRequest);
+    }
+    async resume(input) {
+        return this.#open({ ...input.request, prompt: "" }, input.onPermissionRequest, input.sessionId);
+    }
+    async #open(request, onPermissionRequest, resumeSessionId) {
+        const bridge = getRequiredBridge();
+        const capability = getNativeDesktopCapability("agent-runtime");
+        const protocolVersion = Number(capability?.details?.protocolVersion ?? 2);
+        const supportsSessionConfiguration = protocolVersion >= 5 ||
+            capability?.details?.sessionConfiguration === "configure";
+        const deferredStart = capability?.details?.deferredStart === true;
+        const reconcilesRunStatus = capability?.details?.runStatus === true;
+        const events = new AsyncEventQueue();
+        let sessionId = deferredStart
+            ? (resumeSessionId ?? crypto.randomUUID())
+            : "";
+        let activeRunId = null;
+        let lastSequence = 0;
+        let statusFailures = 0;
+        let disposed = false;
+        let statusTimer;
+        const clearStatusTimer = () => {
+            if (statusTimer)
+                clearTimeout(statusTimer);
+            statusTimer = undefined;
+        };
+        const settleActiveRun = (runId) => {
+            if (activeRunId !== runId)
+                return;
+            activeRunId = null;
+            statusFailures = 0;
+            clearStatusTimer();
+        };
+        const deliverRuntimeEvent = (event, deliverySource = "live") => {
+            if (event.sessionId !== sessionId)
+                return;
+            if (activeRunId && event.runId !== activeRunId)
+                return;
+            if (reconcilesRunStatus &&
+                deliverySource === "live" &&
+                activeRunId === event.runId &&
+                isTerminalRuntimeEvent(event)) {
+                clearStatusTimer();
+                void reconcileRunStatus(event.runId);
+                return;
+            }
+            if (event.sequence <= lastSequence)
+                return;
+            lastSequence = event.sequence;
+            const source = {
+                sessionId: event.sessionId,
+                runId: event.runId,
+                sequence: event.sequence,
+            };
+            if (event.event.type === "event" && event.event.event) {
+                events.push({
+                    ...event.event.event,
+                    __source: source,
+                });
+                if (isTerminalRuntimeEvent(event))
+                    settleActiveRun(event.runId);
+                return;
+            }
+            if (event.event.type === "permission" && event.event.request) {
+                const request = {
+                    ...event.event.request,
+                    __source: source,
+                };
+                void onPermissionRequest(request).then((decision) => bridge.invoke("desktop_agent_acp_respond", {
+                    sessionId,
+                    requestId: String(request.requestId ?? request.id),
+                    decision: decision.outcome,
+                }));
+                return;
+            }
+            if (event.event.event?.type === "error") {
+                events.push({
+                    type: "error",
+                    message: String(event.event.event.message ?? "") ||
+                        "Agent-runtime connection closed",
+                    __source: source,
+                });
+            }
+            if (isTerminalRuntimeEvent(event))
+                settleActiveRun(event.runId);
+            events.close();
+        };
+        const failRunStatus = (runId, message) => {
+            if (activeRunId !== runId)
+                return;
+            events.push({ type: "error", message });
+            settleActiveRun(runId);
+            events.close();
+        };
+        const scheduleRunStatus = (runId) => {
+            if (!reconcilesRunStatus || disposed || activeRunId !== runId)
+                return;
+            clearStatusTimer();
+            statusTimer = setTimeout(() => void reconcileRunStatus(runId), RUN_STATUS_POLL_MS);
+        };
+        const reconcileRunStatus = async (runId) => {
+            if (disposed || activeRunId !== runId)
+                return;
+            try {
+                const snapshot = await bridge.invoke("desktop_agent_acp_status", { sessionId });
+                if (disposed || activeRunId !== runId)
+                    return;
+                if (snapshot.runId !== runId || snapshot.state === "idle") {
+                    statusFailures += 1;
+                }
+                else {
+                    statusFailures = 0;
+                }
+                if (snapshot.runId === runId && snapshot.state === "terminal") {
+                    const retained = snapshot.events?.length
+                        ? [...snapshot.events].sort((left, right) => left.sequence - right.sequence)
+                        : snapshot.terminalEvent
+                            ? [snapshot.terminalEvent]
+                            : [];
+                    for (const event of retained)
+                        deliverRuntimeEvent(event, "status");
+                    if (activeRunId === runId) {
+                        failRunStatus(runId, "The desktop agent finished without a recoverable terminal event.");
+                    }
+                    return;
+                }
+            }
+            catch {
+                statusFailures += 1;
+            }
+            if (statusFailures >= MAX_RUN_STATUS_FAILURES) {
+                failRunStatus(runId, "The desktop agent status channel became unavailable.");
+                return;
+            }
+            scheduleRunStatus(runId);
+        };
+        const onRuntimeEvent = (event) => {
+            deliverRuntimeEvent(event);
+        };
+        let unsubscribe = deferredStart
+            ? bridge.onAgentRuntimeEvent?.(onRuntimeEvent)
+            : undefined;
+        try {
+            const started = await bridge.invoke("desktop_agent_acp_start", {
+                ...(deferredStart ? { sessionId } : {}),
+                workspace: request.workspace,
+                agent: request.agent,
+                model: request.model,
+                thinking: request.thinking,
+                metadata: request.metadata,
+                restricted: request.restricted,
+                ...(protocolVersion >= 3
+                    ? {
+                        mcpServers: request.mcpServers,
+                        appToolBridgeId: request.appToolSession?.bridgeId,
+                    }
+                    : { tools: request.mcpServers }),
+                resumeSessionId,
+            });
+            if (deferredStart && started.sessionId !== sessionId) {
+                throw new Error("The desktop agent host returned a different reserved session id.");
+            }
+            sessionId = started.sessionId;
+            unsubscribe ??= bridge.onAgentRuntimeEvent?.(onRuntimeEvent);
+        }
+        catch (error) {
+            unsubscribe?.();
+            events.close();
+            throw error;
+        }
+        const detach = () => {
+            disposed = true;
+            activeRunId = null;
+            clearStatusTimer();
+            unsubscribe?.();
+            events.close();
+        };
+        return {
+            id: sessionId,
+            events: () => events,
+            async prompt(text) {
+                lastSequence = 0;
+                const prompted = await bridge.invoke("desktop_agent_acp_prompt", { sessionId, text });
+                activeRunId = prompted.runId;
+                statusFailures = 0;
+                scheduleRunStatus(prompted.runId);
+            },
+            async configure(input) {
+                if (!supportsSessionConfiguration) {
+                    return {
+                        ...(input.model
+                            ? { model: { status: "unsupported" } }
+                            : {}),
+                        ...(input.thinking
+                            ? { thinking: { status: "unsupported" } }
+                            : {}),
+                    };
+                }
+                return bridge.invoke("desktop_agent_acp_configure", {
+                    sessionId,
+                    model: input.model,
+                    thinking: input.thinking,
+                });
+            },
+            async cancel() {
+                activeRunId = null;
+                clearStatusTimer();
+                await bridge.invoke("desktop_agent_acp_cancel", { sessionId });
+            },
+            async detach() {
+                detach();
+            },
+            async close() {
+                detach();
+                await bridge.invoke("desktop_agent_acp_close", { sessionId });
+            },
+        };
+    }
+}
+function getRequiredBridge() {
+    const bridge = getNativeDesktopBridge();
+    if (!bridge) {
+        throw new Error("The desktop agent-runtime bridge is not registered.");
+    }
+    return bridge;
+}

package/dist/runtimes/codex/app-server-protocol.d.ts

@@ -0,0 +1,28 @@
+import { type AgentEvent, type ApprovalRequest, type UserInputAnswers, type UserInputRequest } from "../../core/types";
+export type AppServerMessage = {
+    id?: string | number;
+    method?: string;
+    params?: unknown;
+    result?: unknown;
+    error?: {
+        message?: string;
+    } | unknown;
+};
+export declare function mapCodexNotification(message: AppServerMessage): AgentEvent | null;
+export declare function approvalRequestFromServerRequest(message: AppServerMessage): ApprovalRequest | null;
+export declare function userInputRequestFromServerRequest(message: AppServerMessage): UserInputRequest | null;
+export declare function userInputReplyForServerRequest(message: AppServerMessage, answers: UserInputAnswers): {
+    result?: Record<string, unknown>;
+    error?: {
+        code: number;
+        message: string;
+    };
+};
+export declare function approvalResponseForOption(optionId: string): Record<string, unknown>;
+export declare function approvalReplyForServerRequest(message: AppServerMessage, optionId: string): {
+    result?: Record<string, unknown>;
+    error?: {
+        code: number;
+        message: string;
+    };
+};