@lapis-notes/ai 0.1.1 → 0.1.5

package/dist/chat/chat-controller.svelte.js

@@ -69,6 +69,7 @@ export class AiChatController {
     #onComposerDefaults;
     #refreshSkills = false;
     #activeRecallAbort;
+    #controllerContextReady = new WeakSet();
     #pendingHandoffs = new WeakMap();
     #approvalGrants = [];
     #followedScope;
@@ -466,32 +467,90 @@ export class AiChatController {
                     return;
                 throw new Error("Agent session did not start.");
             }
-            const recallAbort = new AbortController();
-            this.#activeRecallAbort?.abort();
-            this.#activeRecallAbort = recallAbort;
-            const recalledBlocks = await this.#memoryRecall
-                ?.recall(text, {
-                scopeDir: this.location?.scopeDir ?? this.directoryContext,
-                conversationId: this.location?.conversationId,
-                agentBindingId: this.#activeBindingId,
-                runId: `turn-${turnId}`,
-            }, recallAbort.signal)
-                .catch(() => []);
-            if (this.#activeRecallAbort === recallAbort) {
-                this.#activeRecallAbort = undefined;
+            const session = this.session;
+            const sharedPreparation = this.runtime.capabilities().preparesContext === true;
+            const location = this.location ? { ...this.location } : null;
+            const bindingId = this.#activeBindingId;
+            const authorized = () => !this.#isAbandoned(turnId) &&
+                this.session === session &&
+                this.location?.conversationId === location?.conversationId;
+            const prepareContext = async (signal) => {
+                if (!authorized())
+                    throw new Error("Conversation context is no longer active.");
+                const recallAbort = new AbortController();
+                const abort = () => recallAbort.abort();
+                if (signal.aborted)
+                    abort();
+                signal.addEventListener("abort", abort, { once: true });
+                this.#activeRecallAbort?.abort();
+                this.#activeRecallAbort = recallAbort;
+                try {
+                    let handoff = this.#pendingHandoffs.get(session);
+                    if (sharedPreparation && this.repository && location && bindingId) {
+                        const current = await this.repository.read(location);
+                        const bindings = reduceAgentBindings(current.agents);
+                        const binding = bindings.find((item) => item.id === bindingId);
+                        handoff = await buildConversationContextHandoff(current.transcript, {
+                            conversationId: current.metadata.id,
+                            targetBindingId: bindingId,
+                            ...(this.#controllerContextReady.has(session) &&
+                                binding?.context
+                                ? {
+                                    after: {
+                                        entryId: binding.context.throughEntryId,
+                                        entryHash: binding.context.throughEntryHash,
+                                    },
+                                }
+                                : {}),
+                            bindings,
+                            summaries: current.agents.filter((record) => record.type === "handoff.summary.created"),
+                        });
+                        const context = this.#sessionContexts.get(session);
+                        if (context) {
+                            context.handoff = handoff;
+                            if (context.pendingSwitch?.type === "agent.switch")
+                                Object.assign(context.pendingSwitch, {
+                                    handoffId: handoff?.handoffId,
+                                    handoffMode: handoff?.mode,
+                                    handoffThroughEntryId: handoff?.throughEntryId,
+                                    omittedEntryCount: handoff?.omittedEntryCount,
+                                });
+                        }
+                    }
+                    const recalledBlocks = await this.#memoryRecall
+                        ?.recall(text, {
+                        scopeDir: location?.scopeDir ?? this.directoryContext,
+                        conversationId: location?.conversationId,
+                        agentBindingId: bindingId,
+                        runId: `turn-${turnId}`,
+                    }, recallAbort.signal)
+                        .catch(() => []);
+                    if (recallAbort.signal.aborted || !authorized())
+                        throw new Error("Conversation preparation was cancelled.");
+                    this.#pendingHandoffs.delete(session);
+                    return [
+                        ...(handoff ? [handoff.block] : []),
+                        ...(recalledBlocks ?? []),
+                    ];
+                }
+                finally {
+                    signal.removeEventListener("abort", abort);
+                    if (this.#activeRecallAbort === recallAbort)
+                        this.#activeRecallAbort = undefined;
+                }
+            };
+            if (sharedPreparation) {
+                await session.send(text, {
+                    prepareContext,
+                    authorizeContext: async () => authorized(),
+                });
+            }
+            else {
+                const blocks = await prepareContext(new AbortController().signal);
+                if (this.#isAbandoned(turnId))
+                    return;
+                await session.send(text, { contextBlocks: blocks });
             }
-            if (this.#isAbandoned(turnId))
-                return;
-            const handoff = this.#pendingHandoffs.get(this.session);
-            const contextBlocks = [
-                ...(handoff ? [handoff.block] : []),
-                ...(recalledBlocks ?? []),
-            ];
-            await this.session.send(text, {
-                contextBlocks,
-            });
-            if (handoff)
-                this.#pendingHandoffs.delete(this.session);
             if (!this.repository)
                 await this.#persist();
         }
@@ -753,6 +812,8 @@ export class AiChatController {
         };
         try {
             for await (const event of session.events()) {
+                if (event.type === "completed")
+                    this.#controllerContextReady.add(session);
                 if ((event.type === "tool.start" || event.type === "tool.end") &&
                     event.server === APP_TOOL_MCP_SERVER_NAME) {
                     continue;
@@ -1402,10 +1463,10 @@ export class AiChatController {
         }
         const followedScope = this.#followedScope ?? this.directoryContext;
         const input = this.#followedScope !== undefined || this.directoryContext
-            ? (this.#createConversation?.(followedScope) ?? {
+            ? this.#createConversation?.(followedScope) ?? {
                 scopeDir: followedScope,
-            })
-            : (this.#createConversation?.() ?? { scopeDir: "" });
+            }
+            : this.#createConversation?.() ?? { scopeDir: "" };
         const created = await this.repository.create(input);
         this.location = created.location;
         this.conversationStatus = created.metadata.status;
@@ -1465,7 +1526,7 @@ export class AiChatController {
             this.appToolsUnavailableReason =
                 descriptor.status === "runtime-unavailable" && runtime.id === "fake"
                     ? null
-                    : (descriptor.unavailableReason ?? null);
+                    : descriptor.unavailableReason ?? null;
             return descriptor;
         }
         catch (error) {
@@ -1667,6 +1728,10 @@ export class AiChatController {
                     ...request,
                     appToolSession,
                     skillSnapshot,
+                    metadata: {
+                        ...request.metadata,
+                        ...(await this.#sessionBootstrapMetadata(snapshot.location.scopeDir, snapshot.metadata.launchContext?.notePath, snapshot.metadata.id, appToolSession?.tools ?? [], skillSnapshot?.skills ?? [])),
+                    },
                 });
                 const configured = await this.#configureBinding(resumed, compatibleBinding, request);
                 if (!configured)

package/dist/chat/chat-tool-display.d.ts

@@ -1,17 +1,7 @@
+import { isOneLineToolAlert, presentToolPayload, toolCallTarget } from "@lapismd/design-core/ai/chat";
 import type { AiChatItem } from "./chat-items";
 export type AiChatToolItem = Extract<AiChatItem, {
     type: "tool";
 }>;
-export type ToolPayloadLanguage = "json" | "bash" | "plaintext";
-export type PresentedToolPayload = {
-    code: string;
-    language: ToolPayloadLanguage;
-};
-export type ToolPayloadHint = {
-    toolName?: string;
-    input?: string;
-};
-export declare function presentToolPayload(value?: string, hint?: ToolPayloadHint): PresentedToolPayload | undefined;
-export declare function isOneLineAlert(payload: PresentedToolPayload): boolean;
-export declare function toolCallTarget(input?: string, server?: string): string | undefined;
+export { isOneLineToolAlert as isOneLineAlert, presentToolPayload, toolCallTarget, };
 export declare function toolCallStatus(state: AiChatToolItem["state"]): "complete" | "error" | "running";

package/dist/chat/chat-tool-display.js

@@ -1,70 +1,5 @@
-const SUMMARY_KEYS = [
-    "command",
-    "path",
-    "file",
-    "query",
-    "url",
-    "pattern",
-    "target",
-];
-const PRIMARY_KEYS = [
-    "output",
-    "content",
-    "text",
-    "result",
-    "stdout",
-    "aggregated",
-];
-const METADATA_KEYS = new Set([
-    "ok",
-    "status",
-    "success",
-    "isError",
-    "server",
-    "tool",
-    "name",
-]);
-const STRUCTURAL_SIBLINGS = new Set([
-    "path",
-    "command",
-    "query",
-    "file",
-    "url",
-    "pattern",
-    "target",
-    "locations",
-]);
-const RUNNER_TOOL_NAMES = new Set([
-    "bash",
-    "sh",
-    "shell",
-    "exec",
-    "command",
-    "terminal",
-    "run",
-]);
-const MAX_PARSE_DEPTH = 3;
-export function presentToolPayload(value, hint) {
-    if (value == null || value === "")
-        return undefined;
-    const extracted = extractDisplayValue(value, 0);
-    if (extracted == null || extracted === "")
-        return undefined;
-    if (isRecord(extracted) || Array.isArray(extracted)) {
-        return { code: JSON.stringify(extracted, null, 2), language: "json" };
-    }
-    const text = String(extracted);
-    if (!text)
-        return undefined;
-    return { code: text, language: detectTextLanguage(text, hint) };
-}
-export function isOneLineAlert(payload) {
-    return payload.language === "plaintext" && !payload.code.includes("\n");
-}
-export function toolCallTarget(input, server) {
-    const summary = summarizeToolInput(input);
-    return summary || server || undefined;
-}
+import { isOneLineToolAlert, presentToolPayload, toolCallTarget, } from "@lapismd/design-core/ai/chat";
+export { isOneLineToolAlert as isOneLineAlert, presentToolPayload, toolCallTarget, };
 export function toolCallStatus(state) {
     if (state === "completed")
         return "complete";
@@ -72,142 +7,3 @@ export function toolCallStatus(state) {
         return "error";
     return "running";
 }
-function extractDisplayValue(value, depth) {
-    const parsed = tryParseJson(value);
-    if (parsed === undefined)
-        return value;
-    if (typeof parsed === "string") {
-        if (depth + 1 >= MAX_PARSE_DEPTH)
-            return parsed;
-        return extractDisplayValue(parsed, depth + 1);
-    }
-    if (Array.isArray(parsed) || !isRecord(parsed))
-        return parsed;
-    const mcpText = mcpContentText(parsed);
-    if (mcpText != null)
-        return extractDisplayValue(mcpText, depth + 1);
-    const unwrapped = unwrapEnvelope(parsed);
-    if (unwrapped !== undefined)
-        return extractDisplayValue(unwrapped, depth + 1);
-    return parsed;
-}
-function tryParseJson(value) {
-    if (typeof value !== "string")
-        return value;
-    const trimmed = value.trim();
-    if (!trimmed)
-        return undefined;
-    if (!trimmed.startsWith("{") &&
-        !trimmed.startsWith("[") &&
-        !trimmed.startsWith('"')) {
-        return undefined;
-    }
-    try {
-        return JSON.parse(trimmed);
-    }
-    catch {
-        return undefined;
-    }
-}
-function unwrapEnvelope(record) {
-    const keys = Object.keys(record);
-    const primary = PRIMARY_KEYS.find((key) => record[key] != null && record[key] !== "");
-    if (!primary)
-        return undefined;
-    const rest = keys.filter((key) => key !== primary);
-    if (rest.some((key) => !METADATA_KEYS.has(key)))
-        return undefined;
-    return record[primary];
-}
-function mcpContentText(record) {
-    if (!Array.isArray(record.content) || record.content.length === 0) {
-        return undefined;
-    }
-    const rest = Object.keys(record).filter((key) => key !== "content");
-    if (rest.some((key) => STRUCTURAL_SIBLINGS.has(key)))
-        return undefined;
-    if (rest.some((key) => !METADATA_KEYS.has(key)))
-        return undefined;
-    const parts = record.content.flatMap((entry) => {
-        if (typeof entry === "string" && entry)
-            return [entry];
-        if (isRecord(entry) && typeof entry.text === "string" && entry.text) {
-            return [entry.text];
-        }
-        return [];
-    });
-    return parts.length > 0 ? parts.join("\n") : undefined;
-}
-function detectTextLanguage(text, hint) {
-    if (isRunnerToolName(hint?.toolName))
-        return "bash";
-    if (hasCommandInput(hint?.input))
-        return "bash";
-    if (text.includes("\n"))
-        return "bash";
-    if (looksLikeCli(text))
-        return "bash";
-    return "plaintext";
-}
-function isRunnerToolName(name) {
-    if (!name)
-        return false;
-    const normalized = name.trim().toLowerCase();
-    if (RUNNER_TOOL_NAMES.has(normalized))
-        return true;
-    const leaf = normalized.split(/[:/]/u).at(-1);
-    return leaf != null && RUNNER_TOOL_NAMES.has(leaf);
-}
-function hasCommandInput(input) {
-    if (!input)
-        return false;
-    try {
-        const parsed = JSON.parse(input);
-        return (isRecord(parsed) &&
-            typeof parsed.command === "string" &&
-            parsed.command.trim() !== "");
-    }
-    catch {
-        return false;
-    }
-}
-function looksLikeCli(text) {
-    const trimmed = text.trim();
-    return (/^[$%] /u.test(trimmed) ||
-        /^error:/imu.test(trimmed) ||
-        /\b(?:stderr|exit \d+)\b/iu.test(trimmed) ||
-        /\|/.test(trimmed));
-}
-function summarizeToolInput(input) {
-    if (!input)
-        return undefined;
-    try {
-        const parsed = JSON.parse(input);
-        if (typeof parsed === "string" && parsed.trim())
-            return parsed.trim();
-        if (!isRecord(parsed))
-            return undefined;
-        for (const key of SUMMARY_KEYS) {
-            const value = parsed[key];
-            if (typeof value === "string" && value.trim())
-                return value.trim();
-        }
-        const locations = parsed.locations;
-        if (Array.isArray(locations)) {
-            const first = locations[0];
-            if (isRecord(first) && typeof first.path === "string" && first.path) {
-                return first.path;
-            }
-        }
-    }
-    catch {
-        const line = input.trim().split("\n")[0] ?? "";
-        if (!line)
-            return undefined;
-        return line.length > 80 ? `${line.slice(0, 77)}…` : line;
-    }
-    return undefined;
-}
-function isRecord(value) {
-    return value != null && typeof value === "object" && !Array.isArray(value);
-}

package/dist/chat/composer-model-catalog.d.ts

@@ -0,0 +1,20 @@
+import type { ModelRef } from "../core/types";
+import type { AcpAgentId } from "../settings/acp-agents";
+import type { AiPluginSettings } from "../settings/ai-settings";
+export type ComposerModelCatalogState = {
+    agent: AcpAgentId;
+    runtime: AiPluginSettings["defaultRuntime"];
+    models: ModelRef[];
+    model: string;
+    loading: boolean;
+    error: string | null;
+};
+/** Each selection owns its result; a previous harness cannot overwrite it. */
+export declare class ComposerModelCatalog {
+    #private;
+    readonly load: (agent: AcpAgentId, runtime: AiPluginSettings["defaultRuntime"]) => Promise<ModelRef[]>;
+    readonly update: (state: ComposerModelCatalogState) => void;
+    constructor(load: (agent: AcpAgentId, runtime: AiPluginSettings["defaultRuntime"]) => Promise<ModelRef[]>, update: (state: ComposerModelCatalogState) => void);
+    refresh(agent: AcpAgentId, runtime: AiPluginSettings["defaultRuntime"], saved: string): Promise<void>;
+    cancel(): void;
+}

package/dist/chat/composer-model-catalog.js

@@ -0,0 +1,44 @@
+/** Each selection owns its result; a previous harness cannot overwrite it. */
+export class ComposerModelCatalog {
+    load;
+    update;
+    #generation = 0;
+    constructor(load, update) {
+        this.load = load;
+        this.update = update;
+    }
+    async refresh(agent, runtime, saved) {
+        const generation = ++this.#generation;
+        const state = {
+            agent,
+            runtime,
+            models: [],
+            model: saved,
+            loading: true,
+            error: null,
+        };
+        this.update(state);
+        try {
+            const models = (await this.load(agent, runtime)).filter((model) => model.provider === agent || !model.provider);
+            if (generation !== this.#generation)
+                return;
+            const model = models.some((entry) => entry.model === saved)
+                ? saved
+                : ((models.find((entry) => entry.isDefault) ?? models[0])?.model ??
+                    saved);
+            this.update({ ...state, models, model, loading: false });
+        }
+        catch (error) {
+            if (generation !== this.#generation)
+                return;
+            this.update({
+                ...state,
+                loading: false,
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    cancel() {
+        this.#generation++;
+    }
+}

package/dist/commands/agent.d.ts

@@ -1,7 +1,7 @@
 import type { AcpAgentId } from "../settings/acp-agents";
 export type ComposerAgentSelection = {
     agent: AcpAgentId;
-    runtimePreference: "acp" | "codex-native" | "fake";
+    runtimePreference: "acp" | "codex-native" | "opencode-native" | "fake";
     label: string;
 };
 export declare function composerAgentLabel(agent?: string, runtimePreference?: string): string;

package/dist/commands/agent.js

@@ -21,6 +21,9 @@ const KNOWN = {
         runtimePreference: "codex-native",
         label: "Codex Native",
     },
+    opencode: { agent: "opencode", runtimePreference: "acp", label: "OpenCode ACP" },
+    "opencode-acp": { agent: "opencode", runtimePreference: "acp", label: "OpenCode ACP" },
+    "opencode-native": { agent: "opencode", runtimePreference: "opencode-native", label: "OpenCode Native" },
     fake: { agent: "codex", runtimePreference: "fake", label: "Fake" },
 };
 export function composerAgentLabel(agent, runtimePreference) {
@@ -28,7 +31,9 @@ export function composerAgentLabel(agent, runtimePreference) {
         return "Fake";
     if (runtimePreference === "codex-native")
         return "Codex Native";
-    return agent === "cursor" ? "Cursor ACP" : "Codex ACP";
+    if (runtimePreference === "opencode-native")
+        return "OpenCode Native";
+    return agent === "cursor" ? "Cursor ACP" : agent === "opencode" ? "OpenCode ACP" : "Codex ACP";
 }
 export function parseAgentCommand(raw) {
     const name = raw.trim().toLowerCase();

package/dist/conversations/context-handoff.d.ts

@@ -1,25 +1 @@
-import type { ConversationHandoffContextBlock } from "../core/types";
-import type { AgentBindingCreatedRecord, HandoffSummaryCreatedRecord, HandoffProjectionMode, TranscriptEntry } from "./types";
-export declare const MAX_CONTEXT_HANDOFF_TOKENS = 12000;
-export declare const MAX_CONTEXT_HANDOFF_CODE_POINTS: number;
-export type ConversationContextCursor = {
-    entryId: string;
-    entryHash: string;
-};
-export type ConversationContextHandoff = {
-    block: ConversationHandoffContextBlock;
-    throughEntryId: string;
-    throughEntryHash: string;
-    handoffId: string;
-    mode: HandoffProjectionMode;
-    omittedEntryCount: number;
-};
-export type ConversationContextHandoffOptions = {
-    conversationId?: string;
-    targetBindingId?: string;
-    after?: ConversationContextCursor;
-    bindings?: readonly AgentBindingCreatedRecord[];
-    summaries?: readonly HandoffSummaryCreatedRecord[];
-    maxTokens?: number;
-};
-export declare function buildConversationContextHandoff(transcript: readonly TranscriptEntry[], options?: ConversationContextHandoffOptions | number): Promise<ConversationContextHandoff | undefined>;
+export { buildConversationContextHandoff, MAX_CONTEXT_HANDOFF_TOKENS, MAX_CONTEXT_HANDOFF_CODE_POINTS, type ConversationContextCursor, type ConversationContextHandoff, type ConversationContextHandoffOptions, } from "@lapismd/ai-controller/memory/lapis";