@lapis-notes/ai 0.1.0

package/dist/providers/codex-model-provider.d.ts

@@ -0,0 +1,12 @@
+import type { AgentProcessHost } from "../host/process-host";
+import type { ModelRef } from "../core/types";
+import type { ModelProvider, ProviderAuthStatus } from "./model-provider";
+export declare class CodexModelProvider implements ModelProvider {
+    #private;
+    readonly id = "codex";
+    constructor(host: AgentProcessHost, options?: {
+        cwd?: string;
+    });
+    listModels(): Promise<ModelRef[]>;
+    authStatus(): Promise<ProviderAuthStatus>;
+}

package/dist/providers/codex-model-provider.js

@@ -0,0 +1,42 @@
+import { listCodexModelsFromHost } from "./codex-model-catalog";
+export class CodexModelProvider {
+    id = "codex";
+    #host;
+    #cwd;
+    constructor(host, options = {}) {
+        this.#host = host;
+        this.#cwd = options.cwd;
+    }
+    async listModels() {
+        if (!this.#host.available)
+            return [];
+        return listCodexModelsFromHost(this.#host, { cwd: this.#cwd });
+    }
+    async authStatus() {
+        if (!this.#host.available) {
+            return {
+                authenticated: false,
+                label: "Codex",
+                detail: "Live model listing requires the desktop agent-runtime capability.",
+            };
+        }
+        let models;
+        try {
+            models = await this.listModels();
+        }
+        catch (error) {
+            return {
+                authenticated: false,
+                label: "Codex",
+                detail: error instanceof Error ? error.message : String(error),
+            };
+        }
+        return models.length > 0
+            ? { authenticated: true, label: "Codex" }
+            : {
+                authenticated: false,
+                label: "Codex",
+                detail: "Codex did not return a model catalog.",
+            };
+    }
+}

package/dist/providers/model-provider.d.ts

@@ -0,0 +1,26 @@
+import type { ModelRef } from "../core/types";
+export type ProviderAuthStatus = {
+    authenticated: boolean;
+    label?: string;
+    detail?: string;
+};
+export interface ModelProvider {
+    readonly id: string;
+    listModels(): Promise<ModelRef[]>;
+    authStatus(): Promise<ProviderAuthStatus>;
+}
+export interface AgentModelCatalog {
+    listModels(provider: string): Promise<ModelRef[]>;
+}
+export declare class ModelProviderRegistry implements AgentModelCatalog {
+    #private;
+    constructor(providers?: ModelProvider[]);
+    listModels(provider: string): Promise<ModelRef[]>;
+}
+export declare class StaticModelProvider implements ModelProvider {
+    #private;
+    readonly id: string;
+    constructor(id: string, models: ModelRef[], auth?: ProviderAuthStatus);
+    listModels(): Promise<ModelRef[]>;
+    authStatus(): Promise<ProviderAuthStatus>;
+}

package/dist/providers/model-provider.js

@@ -0,0 +1,26 @@
+export class ModelProviderRegistry {
+    #providers = new Map();
+    constructor(providers = []) {
+        for (const provider of providers)
+            this.#providers.set(provider.id, provider);
+    }
+    async listModels(provider) {
+        return (await this.#providers.get(provider)?.listModels()) ?? [];
+    }
+}
+export class StaticModelProvider {
+    id;
+    #models;
+    #auth;
+    constructor(id, models, auth = { authenticated: true, label: "Local" }) {
+        this.id = id;
+        this.#models = models;
+        this.#auth = auth;
+    }
+    async listModels() {
+        return [...this.#models];
+    }
+    async authStatus() {
+        return { ...this.#auth };
+    }
+}

package/dist/public-components.d.ts

@@ -0,0 +1,3 @@
+export { default as AiCatalogPanel } from "./catalog/ai-catalog-panel.svelte";
+export { default as AiChatPanel } from "./chat/ai-chat-panel.svelte";
+export { default as AiHistoryPanel } from "./history/ai-history-panel.svelte";

package/dist/public-components.js

@@ -0,0 +1,3 @@
+export { default as AiCatalogPanel } from "./catalog/ai-catalog-panel.svelte";
+export { default as AiChatPanel } from "./chat/ai-chat-panel.svelte";
+export { default as AiHistoryPanel } from "./history/ai-history-panel.svelte";

package/dist/registry/runtime-registry.d.ts

@@ -0,0 +1,11 @@
+import type { AgentRequest, AgentRuntime } from "../core/types";
+export declare class AgentRuntimeNotFoundError extends Error {
+    constructor(message?: string);
+}
+export interface AgentRuntimeRegistry {
+    register(runtime: AgentRuntime): void;
+    get(id: string): AgentRuntime | undefined;
+    list(): AgentRuntime[];
+    select(request: AgentRequest): Promise<AgentRuntime>;
+}
+export declare function createAgentRuntimeRegistry(runtimes?: AgentRuntime[]): AgentRuntimeRegistry;

package/dist/registry/runtime-registry.js

@@ -0,0 +1,71 @@
+export class AgentRuntimeNotFoundError extends Error {
+    constructor(message = "No compatible agent runtime is registered.") {
+        super(message);
+        this.name = "AgentRuntimeNotFoundError";
+    }
+}
+export function createAgentRuntimeRegistry(runtimes = []) {
+    const registered = new Map();
+    for (const runtime of runtimes)
+        registered.set(runtime.id, runtime);
+    return {
+        register(runtime) {
+            registered.set(runtime.id, runtime);
+        },
+        get(id) {
+            return registered.get(id);
+        },
+        list() {
+            return [...registered.values()];
+        },
+        async select(request) {
+            const preferredId = typeof request.metadata?.runtime === "string"
+                ? request.metadata.runtime
+                : undefined;
+            if (preferredId) {
+                const preferred = registered.get(preferredId);
+                if (preferred && (await preferred.supports(request)))
+                    return preferred;
+            }
+            const candidates = [];
+            for (const runtime of registered.values()) {
+                if (await runtime.supports(request))
+                    candidates.push(runtime);
+            }
+            if (candidates.length === 0)
+                throw new AgentRuntimeNotFoundError();
+            return candidates.sort(compareRuntimes)[0];
+        },
+    };
+}
+function compareRuntimes(left, right) {
+    const leftScore = scoreRuntime(left);
+    const rightScore = scoreRuntime(right);
+    if (leftScore !== rightScore)
+        return rightScore - leftScore;
+    return left.id.localeCompare(right.id);
+}
+function scoreRuntime(runtime) {
+    const capabilities = runtime.capabilities();
+    const approvals = capabilities.approvals;
+    let score = 0;
+    if (approvals.supported)
+        score += 4;
+    if (approvals.interactive)
+        score += 4;
+    if (approvals.persistentDecisions)
+        score += 2;
+    if (approvals.granularPermissions)
+        score += 2;
+    if (capabilities.mcpTools)
+        score += 2;
+    if (capabilities.nativeTools)
+        score += 2;
+    if (capabilities.steer)
+        score += 1;
+    if (capabilities.modelSelection)
+        score += 1;
+    if (approvals.policyAmendments)
+        score -= 1;
+    return score;
+}

package/dist/registry/select-runtime.d.ts

@@ -0,0 +1,9 @@
+import type { AgentRequest, AgentRuntime } from "../core/types";
+import type { AiPluginSettings } from "../settings/ai-settings";
+import { type AgentRuntimeRegistry } from "./runtime-registry";
+export declare function selectAgentRuntime(options: {
+    registry: AgentRuntimeRegistry;
+    settings: Pick<AiPluginSettings, "defaultRuntime" | "acpAgent">;
+    request: AgentRequest;
+    fake: AgentRuntime;
+}): Promise<AgentRuntime>;

package/dist/registry/select-runtime.js

@@ -0,0 +1,31 @@
+import { normalizeAcpAgent } from "../settings/acp-agents";
+import { AgentRuntimeNotFoundError, } from "./runtime-registry";
+export async function selectAgentRuntime(options) {
+    const { registry, settings, fake } = options;
+    const agent = normalizeAcpAgent(options.request.agent ?? settings.acpAgent);
+    const request = {
+        ...options.request,
+        agent,
+        metadata: {
+            ...options.request.metadata,
+            acpAgent: agent,
+        },
+    };
+    if (settings.defaultRuntime === "fake")
+        return fake;
+    if (settings.defaultRuntime !== "auto") {
+        const pinned = registry.get(settings.defaultRuntime);
+        if (pinned && (await pinned.supports(request)))
+            return pinned;
+        throw new AgentRuntimeNotFoundError(`Pinned runtime ${settings.defaultRuntime} is unavailable.`);
+    }
+    try {
+        return await registry.select(request);
+    }
+    catch (error) {
+        if (error instanceof AgentRuntimeNotFoundError && (await fake.supports(request))) {
+            return fake;
+        }
+        throw error;
+    }
+}

package/dist/runtime-adapters.d.ts

@@ -0,0 +1,16 @@
+export { createAgentProcessHost } from "./host/desktop-process-host";
+export { UnavailableAgentProcessHost } from "./host/process-host";
+export type { AgentProcessHandle, AgentProcessHost, AgentProcessMessage, } from "./host/process-host";
+export { AcpAgentRuntime } from "./runtimes/acp/acp-runtime";
+export type { AcpRuntimeBackend } from "./runtimes/acp/acp-runtime";
+export { DesktopAcpRuntimeBackend } from "./runtimes/acp/desktop-acp-backend";
+export { buildConversationContextHandoff } from "./conversations/context-handoff";
+export type { AgentSession } from "./core/types";
+export type { AgentBindingCreatedRecord, TranscriptEntry, } from "./conversations/types";
+export { mapAcpPermissionRequest, mapAcpRuntimeEvent, mapApprovalOptionToAcpDecision, } from "./runtimes/acp/acp-event-mapper";
+export type { AcpPermissionDecision } from "./runtimes/acp/acp-event-mapper";
+export { CodexNativeRuntime } from "./runtimes/codex/codex-runtime";
+export { AppToolApprovalBroker, AppToolExecutionError, AppToolHost, } from "./tools/app-tool-host";
+export type { AppToolCall, AppToolExecutionErrorCode, AppToolPolicySettings, CreateAppToolSessionInput, } from "./tools/app-tool-host";
+export { DesktopAppToolBridge } from "./tools/desktop-app-tool-bridge";
+export type { AppToolBridgeCoordinator, AppToolBridgeEvent, } from "./tools/desktop-app-tool-bridge";

package/dist/runtime-adapters.js

@@ -0,0 +1,9 @@
+export { createAgentProcessHost } from "./host/desktop-process-host";
+export { UnavailableAgentProcessHost } from "./host/process-host";
+export { AcpAgentRuntime } from "./runtimes/acp/acp-runtime";
+export { DesktopAcpRuntimeBackend } from "./runtimes/acp/desktop-acp-backend";
+export { buildConversationContextHandoff } from "./conversations/context-handoff";
+export { mapAcpPermissionRequest, mapAcpRuntimeEvent, mapApprovalOptionToAcpDecision, } from "./runtimes/acp/acp-event-mapper";
+export { CodexNativeRuntime } from "./runtimes/codex/codex-runtime";
+export { AppToolApprovalBroker, AppToolExecutionError, AppToolHost, } from "./tools/app-tool-host";
+export { DesktopAppToolBridge } from "./tools/desktop-app-tool-bridge";

package/dist/runtimes/acp/acp-event-mapper.d.ts

@@ -0,0 +1,56 @@
+import { type AgentEvent, type AgentEventSource, type ApprovalRequest } from "../../core/types";
+export type AcpRuntimeEventLike = {
+    type: string;
+    text?: string;
+    tag?: string;
+    used?: number;
+    size?: number;
+    stream?: "output" | "thought";
+    toolCallId?: string;
+    title?: string;
+    status?: string;
+    kind?: string;
+    rawInput?: unknown;
+    rawOutput?: unknown;
+    locations?: unknown[];
+    content?: unknown[];
+    message?: string;
+    stopReason?: string;
+    commands?: Array<{
+        name?: string;
+        description?: string;
+        argumentHint?: string;
+        hint?: string;
+    }>;
+    __source?: AgentEventSource;
+};
+export type AcpPermissionRequestLike = {
+    requestId?: string;
+    id?: string;
+    sessionId?: string;
+    title?: string;
+    kind?: string;
+    inferredKind?: string;
+    toolName?: string;
+    tool?: {
+        name?: string;
+        input?: unknown;
+    };
+    input?: unknown;
+    raw?: Record<string, unknown>;
+    options?: Array<{
+        optionId?: string;
+        id?: string;
+        name?: string;
+        label?: string;
+        kind?: string;
+    }>;
+    __source?: AgentEventSource;
+    [key: string]: unknown;
+};
+export type AcpPermissionDecision = {
+    outcome: "allow_once" | "allow_always" | "reject_once" | "reject_always" | "cancel";
+};
+export declare function mapAcpRuntimeEvent(event: AcpRuntimeEventLike): AgentEvent | null;
+export declare function mapAcpPermissionRequest(request: AcpPermissionRequestLike): ApprovalRequest;
+export declare function mapApprovalOptionToAcpDecision(optionId: string): AcpPermissionDecision;

package/dist/runtimes/acp/acp-event-mapper.js

@@ -0,0 +1,237 @@
+import { isEmptyToolInput, isGenericToolName, toolNameFromInput, } from "../../chat/chat-tool-identity";
+import { DEFAULT_APPROVAL_OPTIONS, } from "../../core/types";
+export function mapAcpRuntimeEvent(event) {
+    if (event.type === "text_delta") {
+        if (event.stream === "thought") {
+            return withSource(event, {
+                type: "thinking",
+                text: event.text ?? "",
+                kind: "reasoning",
+            });
+        }
+        return withSource(event, { type: "text", text: event.text ?? "" });
+    }
+    if (event.type === "available_commands_update") {
+        return withSource(event, {
+            type: "commands.update",
+            commands: nativeCommandsFromAcp(event),
+        });
+    }
+    if (event.type === "status") {
+        const usage = usageFromAcpStatus(event);
+        if (usage)
+            return withSource(event, { type: "usage", usage });
+        if (event.commands) {
+            return withSource(event, {
+                type: "commands.update",
+                commands: nativeCommandsFromAcp(event),
+            });
+        }
+        return withSource(event, {
+            type: "status",
+            status: event.text ?? event.status ?? "status",
+        });
+    }
+    if (event.type === "tool_call") {
+        const id = event.toolCallId ?? event.title ?? "acp-tool";
+        const name = acpToolName(event);
+        if (event.status === "completed" || event.status === "failed") {
+            return withSource(event, {
+                type: "tool.end",
+                id,
+                name,
+                input: acpToolInput(event),
+                output: event.rawOutput ?? event.content ?? event.text,
+                error: event.status === "failed"
+                    ? (event.rawOutput ?? event.content ?? event.text)
+                    : undefined,
+            });
+        }
+        return withSource(event, {
+            type: "tool.start",
+            id,
+            name,
+            input: acpToolInput(event),
+        });
+    }
+    if (event.type === "done") {
+        return withSource(event, {
+            type: "completed",
+            result: { stopReason: event.stopReason },
+        });
+    }
+    if (event.type === "error") {
+        return withSource(event, {
+            type: "error",
+            error: new Error(event.message ?? "ACP runtime error"),
+        });
+    }
+    return null;
+}
+function withSource(event, mapped) {
+    return event.__source ? { ...mapped, source: { ...event.__source } } : mapped;
+}
+function usageFromAcpStatus(event) {
+    if (event.tag === "usage_update" &&
+        isFiniteNonNegative(event.used) &&
+        isFinitePositive(event.size)) {
+        return { used: event.used, limit: event.size };
+    }
+    const match = event.text?.match(/^usage updated:\s*([\d,]+)\s*\/\s*([\d,]+)$/i);
+    if (!match)
+        return null;
+    const used = Number(match[1]?.replaceAll(",", ""));
+    const limit = Number(match[2]?.replaceAll(",", ""));
+    return isFiniteNonNegative(used) && isFinitePositive(limit)
+        ? { used, limit }
+        : null;
+}
+function nativeCommandsFromAcp(event) {
+    return (event.commands ?? [])
+        .map((command) => ({
+        name: (command.name ?? "").trim(),
+        description: command.description,
+        argumentHint: command.argumentHint ?? command.hint,
+    }))
+        .filter((command) => command.name.length > 0);
+}
+function isFiniteNonNegative(value) {
+    return typeof value === "number" && Number.isFinite(value) && value >= 0;
+}
+function isFinitePositive(value) {
+    return typeof value === "number" && Number.isFinite(value) && value > 0;
+}
+export function mapAcpPermissionRequest(request) {
+    const raw = isRecord(request.raw) ? request.raw : {};
+    const toolCall = isRecord(raw.toolCall) ? raw.toolCall : {};
+    const id = String(request.requestId ??
+        request.id ??
+        toolCall.toolCallId ??
+        raw.toolCallId ??
+        cryptoRandomId());
+    const options = mapApprovalOptions(request.options ??
+        (Array.isArray(raw.options)
+            ? raw.options
+            : undefined));
+    const toolName = request.tool?.name ??
+        request.toolName ??
+        stringValue(toolCall.title) ??
+        stringValue(toolCall.kind);
+    const input = request.tool?.input ?? request.input ?? toolCall.rawInput;
+    return {
+        id,
+        origin: "runtime",
+        kind: mapApprovalKind(request.kind ?? request.inferredKind ?? stringValue(toolCall.kind)),
+        title: request.title ??
+            stringValue(toolCall.title) ??
+            (toolName ? `Allow ${toolName}?` : "Allow this agent action?"),
+        tool: toolName
+            ? {
+                name: String(toolName),
+                input,
+            }
+            : undefined,
+        options: options.length > 0 ? options : DEFAULT_APPROVAL_OPTIONS,
+    };
+}
+export function mapApprovalOptionToAcpDecision(optionId) {
+    switch (optionId) {
+        case "allow-always":
+        case "allow_always":
+            return { outcome: "allow_always" };
+        case "deny-once":
+        case "deny_once":
+        case "reject-once":
+        case "reject_once":
+            return { outcome: "reject_once" };
+        case "deny-always":
+        case "deny_always":
+        case "reject-always":
+        case "reject_always":
+            return { outcome: "reject_always" };
+        case "cancel":
+            return { outcome: "cancel" };
+        default:
+            return { outcome: "allow_once" };
+    }
+}
+function acpToolName(event) {
+    const title = stringValue(event.title);
+    if (title && !isGenericToolName(title))
+        return title;
+    return (toolNameFromInput(event.rawInput) ?? stringValue(event.kind) ?? "acp_tool");
+}
+function acpToolInput(event) {
+    if (!isEmptyToolInput(event.rawInput))
+        return event.rawInput;
+    if (Array.isArray(event.locations) && event.locations.length > 0) {
+        return { locations: event.locations };
+    }
+    return undefined;
+}
+function isRecord(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function stringValue(value) {
+    return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+function mapApprovalOptions(options) {
+    if (!options?.length)
+        return [];
+    return options.map((option, index) => {
+        const id = String(option.optionId ?? option.id ?? `option-${index}`);
+        const kind = normalizeOptionKind(option.kind ?? id);
+        return {
+            id,
+            label: option.label ?? option.name ?? labelForKind(kind),
+            kind,
+        };
+    });
+}
+function mapApprovalKind(kind) {
+    if (kind === "read" || kind === "search")
+        return "read";
+    if (kind === "write" ||
+        kind === "edit" ||
+        kind === "delete" ||
+        kind === "move") {
+        return "write";
+    }
+    if (kind === "execute")
+        return "execute";
+    if (kind === "network" || kind === "fetch")
+        return "network";
+    return "other";
+}
+function normalizeOptionKind(value) {
+    const normalized = value.replaceAll("_", "-");
+    if (normalized === "allow-once" ||
+        normalized === "allow-always" ||
+        normalized === "deny-once" ||
+        normalized === "deny-always") {
+        return normalized;
+    }
+    if (normalized.includes("always") && normalized.includes("deny")) {
+        return "deny-always";
+    }
+    if (normalized.includes("always"))
+        return "allow-always";
+    if (normalized.includes("deny"))
+        return "deny-once";
+    return "allow-once";
+}
+function labelForKind(kind) {
+    switch (kind) {
+        case "allow-always":
+            return "Allow always";
+        case "deny-once":
+            return "Deny once";
+        case "deny-always":
+            return "Deny always";
+        default:
+            return "Allow once";
+    }
+}
+function cryptoRandomId() {
+    return `acp-${Math.random().toString(36).slice(2, 10)}`;
+}

package/dist/runtimes/acp/acp-runtime.d.ts

@@ -0,0 +1,46 @@
+import { type AgentCapabilities, type AgentEvent, type AgentRequest, type AgentRuntime, type AgentSession, type AgentSessionConfiguration, type AgentSessionConfigurationResult, type AgentTurnOptions } from "../../core/types";
+import { type AcpPermissionDecision, type AcpPermissionRequestLike, type AcpRuntimeEventLike } from "./acp-event-mapper";
+import type { SkillActivation } from "../../skills/types";
+export type AcpBackendSession = {
+    id: string;
+    events(): AsyncIterable<AcpRuntimeEventLike>;
+    prompt(text: string): Promise<void>;
+    configure?(input: AgentSessionConfiguration): Promise<AgentSessionConfigurationResult>;
+    cancel(): Promise<void>;
+    detach?(): Promise<void>;
+    close(): Promise<void>;
+};
+export type AcpRuntimeBackend = {
+    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>;
+};
+export declare class AcpAgentSession implements AgentSession {
+    #private;
+    readonly id: string;
+    constructor(backend: AcpBackendSession, activations?: readonly SkillActivation[]);
+    events(): AsyncIterable<AgentEvent>;
+    send(input: string, options?: AgentTurnOptions): Promise<void>;
+    configure(input: AgentSessionConfiguration): Promise<AgentSessionConfigurationResult>;
+    respondToApproval(requestId: string, optionId: string): Promise<void>;
+    cancel(): Promise<void>;
+    detach(): Promise<void>;
+    close(): Promise<void>;
+    handlePermissionRequest(request: AcpPermissionRequestLike): Promise<AcpPermissionDecision>;
+}
+export declare class AcpAgentRuntime implements AgentRuntime {
+    #private;
+    readonly id = "acp";
+    constructor(backend: AcpRuntimeBackend);
+    capabilities(): AgentCapabilities;
+    supports(request: AgentRequest): Promise<boolean>;
+    start(request: AgentRequest): Promise<AgentSession>;
+    resume(sessionId: string, request?: Omit<AgentRequest, "prompt">): Promise<AgentSession>;
+}