@lapis-notes/ai 0.1.2 → 0.1.5

package/dist/memory/paths.d.ts

@@ -1,13 +1 @@
-import type { MemoryScope } from "./types";
-export declare const AI_MEMORY_EPISODIC_PROVIDER_ID = "ai-memory-episodic";
-export declare const AI_MEMORY_CURATED_PROVIDER_ID = "ai-memory-curated";
-export declare const AI_MEMORY_PATH_PREFIX = "ai-memory";
-export declare function decodeMemoryPathSegment(value: string): string;
-export declare function conversationMemoryScope(scopeDir: string): MemoryScope;
-export declare function memoryScopeKey(scope: MemoryScope): string;
-export declare function episodicScopePrefix(scope: MemoryScope): string;
-export declare function episodicMemoryPath(scope: MemoryScope, conversationId: string, entryId: string): string;
-export declare function curatedScopePrefix(scope: MemoryScope): string;
-export declare function curatedMemoryPath(scope: MemoryScope, memoryId: string): string;
-export declare function currentMemoryScopes(scopeDir: string): MemoryScope[];
-export declare function scopeProximity(scope: MemoryScope, currentScopeDir: string): number;
+export { AI_MEMORY_EPISODIC_PROVIDER_ID, AI_MEMORY_CURATED_PROVIDER_ID, AI_MEMORY_PATH_PREFIX, decodeMemoryPathSegment, conversationMemoryScope, memoryScopeKey, episodicScopePrefix, episodicMemoryPath, curatedScopePrefix, curatedMemoryPath, currentMemoryScopes, scopeProximity, } from "@lapismd/ai-controller/memory/lapis";

package/dist/memory/paths.js

@@ -1,60 +1 @@
-export const AI_MEMORY_EPISODIC_PROVIDER_ID = "ai-memory-episodic";
-export const AI_MEMORY_CURATED_PROVIDER_ID = "ai-memory-curated";
-export const AI_MEMORY_PATH_PREFIX = "ai-memory";
-function encodeSegment(value) {
-    return encodeURIComponent(value).replaceAll("%", "~");
-}
-export function decodeMemoryPathSegment(value) {
-    return decodeURIComponent(value.replaceAll("~", "%"));
-}
-export function conversationMemoryScope(scopeDir) {
-    return scopeDir
-        ? { kind: "project", projectDir: scopeDir }
-        : { kind: "workspace" };
-}
-export function memoryScopeKey(scope) {
-    return scope.kind === "project"
-        ? `project:${scope.projectDir}`
-        : `${scope.kind}:`;
-}
-export function episodicScopePrefix(scope) {
-    if (scope.kind === "project") {
-        return `${AI_MEMORY_PATH_PREFIX}/episodic/project/${encodeSegment(scope.projectDir)}`;
-    }
-    return `${AI_MEMORY_PATH_PREFIX}/episodic/${scope.kind}/_`;
-}
-export function episodicMemoryPath(scope, conversationId, entryId) {
-    return `${episodicScopePrefix(scope)}/${encodeSegment(conversationId)}/${encodeSegment(entryId)}`;
-}
-export function curatedScopePrefix(scope) {
-    if (scope.kind === "project") {
-        return `${AI_MEMORY_PATH_PREFIX}/curated/project/${encodeSegment(scope.projectDir)}`;
-    }
-    return `${AI_MEMORY_PATH_PREFIX}/curated/${scope.kind}/_`;
-}
-export function curatedMemoryPath(scope, memoryId) {
-    return `${curatedScopePrefix(scope)}/${encodeSegment(memoryId)}`;
-}
-export function currentMemoryScopes(scopeDir) {
-    const scopes = [{ kind: "user" }, { kind: "workspace" }];
-    if (!scopeDir)
-        return scopes;
-    const segments = scopeDir.split("/");
-    const projects = [];
-    for (let index = segments.length; index > 0 && projects.length < 8; index -= 1) {
-        projects.push({ kind: "project", projectDir: segments.slice(0, index).join("/") });
-    }
-    return [...scopes, ...projects];
-}
-export function scopeProximity(scope, currentScopeDir) {
-    if (scope.kind === "user")
-        return 0.75;
-    if (scope.kind === "workspace")
-        return currentScopeDir ? 0.8 : 1;
-    if (scope.projectDir === currentScopeDir)
-        return 1;
-    if (!currentScopeDir.startsWith(`${scope.projectDir}/`))
-        return 0.35;
-    const distance = currentScopeDir.split("/").length - scope.projectDir.split("/").length;
-    return Math.max(0.45, 0.9 - distance * 0.08);
-}
+export { AI_MEMORY_EPISODIC_PROVIDER_ID, AI_MEMORY_CURATED_PROVIDER_ID, AI_MEMORY_PATH_PREFIX, decodeMemoryPathSegment, conversationMemoryScope, memoryScopeKey, episodicScopePrefix, episodicMemoryPath, curatedScopePrefix, curatedMemoryPath, currentMemoryScopes, scopeProximity, } from "@lapismd/ai-controller/memory/lapis";

package/dist/memory/runtime-consolidation-provider.d.ts

@@ -1,18 +1,2 @@
-import type { AgentRequest, AgentRuntime } from "../core/types";
-import type { ConsolidationProposal, GroundedConsolidationInput, MemoryConsolidationProvider } from "./types";
-export type RuntimeConsolidationConfiguration = {
-    runtimeId: "acp" | "codex-native";
-    agent: "codex" | "cursor";
-    model: string;
-};
-export type RuntimeMemoryConsolidationProviderOptions = {
-    configuration: () => RuntimeConsolidationConfiguration;
-    resolveRuntime: (request: AgentRequest) => Promise<AgentRuntime>;
-    timeoutMs?: number;
-};
-export declare class RuntimeMemoryConsolidationProvider implements MemoryConsolidationProvider {
-    #private;
-    private readonly options;
-    constructor(options: RuntimeMemoryConsolidationProviderOptions);
-    propose(input: GroundedConsolidationInput, signal?: AbortSignal): Promise<ConsolidationProposal>;
-}
+export { RuntimeMemoryConsolidationProvider } from "@lapismd/ai-controller/memory/lapis";
+export type { RuntimeConsolidationConfiguration, RuntimeMemoryConsolidationProviderOptions, } from "@lapismd/ai-controller/memory/lapis";

package/dist/memory/runtime-consolidation-provider.js

@@ -1,154 +1 @@
-const MAX_INPUT_CHARS = 32_000;
-const MAX_OUTPUT_CHARS = 64_000;
-const DEFAULT_TIMEOUT_MS = 60_000;
-export class RuntimeMemoryConsolidationProvider {
-    options;
-    #timeoutMs;
-    constructor(options) {
-        this.options = options;
-        this.#timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
-    }
-    async propose(input, signal) {
-        const configuration = this.options.configuration();
-        if (!configuration.model.trim()) {
-            throw new Error("Memory consolidation requires a pinned model.");
-        }
-        const prompt = consolidationPrompt(input);
-        const request = {
-            prompt: "",
-            agent: configuration.agent,
-            model: {
-                provider: configuration.agent,
-                model: configuration.model.trim(),
-            },
-            thinking: "low",
-            metadata: {
-                runtime: configuration.runtimeId,
-                purpose: "memory-consolidation",
-            },
-            mcpServers: [],
-            restricted: true,
-            requireApprovals: false,
-            requirePolicyAmendments: false,
-        };
-        const runtime = await this.options.resolveRuntime(request);
-        const session = await runtime.start(request);
-        const deadline = new AbortController();
-        const timer = setTimeout(() => deadline.abort(new Error("Memory consolidation timed out.")), this.#timeoutMs);
-        const abort = () => deadline.abort(signal?.reason);
-        signal?.addEventListener("abort", abort, { once: true });
-        try {
-            return await collectProposal(session, prompt, deadline.signal);
-        }
-        finally {
-            clearTimeout(timer);
-            signal?.removeEventListener("abort", abort);
-            await session.close().catch(() => undefined);
-        }
-    }
-}
-async function collectProposal(session, prompt, signal) {
-    let output = "";
-    let completed = false;
-    const cancelOnAbort = () => void session.cancel?.().catch(() => undefined);
-    signal.addEventListener("abort", cancelOnAbort, { once: true });
-    const send = session.send(prompt);
-    const events = session.events()[Symbol.asyncIterator]();
-    try {
-        while (true) {
-            const next = await nextEvent(events, signal);
-            if (next.done)
-                break;
-            const event = next.value;
-            assertReadOnlyEvent(event);
-            if (event.type === "text") {
-                output += event.text;
-                if (output.length > MAX_OUTPUT_CHARS) {
-                    await session.cancel?.().catch(() => undefined);
-                    throw new Error("Memory consolidation output exceeded its limit.");
-                }
-            }
-            if (event.type === "error")
-                throw event.error;
-            if (event.type === "completed") {
-                completed = true;
-                break;
-            }
-        }
-        await send;
-        if (!completed)
-            throw new Error("Memory consolidation ended without completion.");
-        return parseProposal(output);
-    }
-    catch (error) {
-        await session.cancel?.().catch(() => undefined);
-        await send.catch(() => undefined);
-        throw error;
-    }
-    finally {
-        signal.removeEventListener("abort", cancelOnAbort);
-        await events.return?.().catch(() => undefined);
-    }
-}
-function nextEvent(events, signal) {
-    if (signal.aborted)
-        return Promise.reject(signal.reason);
-    return new Promise((resolve, reject) => {
-        const onAbort = () => reject(signal.reason);
-        signal.addEventListener("abort", onAbort, { once: true });
-        void events.next().then((next) => {
-            signal.removeEventListener("abort", onAbort);
-            resolve(next);
-        }, (error) => {
-            signal.removeEventListener("abort", onAbort);
-            reject(error);
-        });
-    });
-}
-function assertReadOnlyEvent(event) {
-    if (event.type === "tool.start" ||
-        event.type === "tool.end" ||
-        event.type === "command.start" ||
-        event.type === "command.end" ||
-        event.type === "file.changed" ||
-        event.type === "permission.request" ||
-        event.type === "question.request") {
-        throw new Error(`Memory consolidation aborted on forbidden runtime event: ${event.type}`);
-    }
-}
-function consolidationPrompt(input) {
-    const payload = JSON.stringify({
-        scope: input.scope,
-        candidates: input.candidates.slice(0, 10).map((candidate) => ({
-            id: candidate.id,
-            claim: candidate.claim.slice(0, 2_000),
-            evidence: candidate.evidence.slice(0, 20).map((evidence) => ({
-                conversationId: evidence.conversationId,
-                entryId: evidence.entryId,
-                entryHash: evidence.entryHash,
-                observedAt: evidence.observedAt,
-            })),
-        })),
-    });
-    if (payload.length > MAX_INPUT_CHARS) {
-        throw new Error("Memory consolidation input exceeded its limit.");
-    }
-    return [
-        "You are a restricted memory consolidation processor.",
-        "Return exactly one JSON object and no markdown or commentary.",
-        "Use only the supplied candidates. Do not invent candidate IDs or evidence.",
-        "The object must be {\"memories\":[{\"candidateIds\":[string],\"kind\":\"preference\"|\"fact\"|\"decision\"|\"procedure\"|\"constraint\",\"scope\":MemoryScope,\"importance\":1|2|3|4|5,\"triggers\":[string],\"summary\":string,\"supersessionKey\"?:string}]}.",
-        "Input:",
-        payload,
-    ].join("\n");
-}
-function parseProposal(output) {
-    const parsed = JSON.parse(output.trim());
-    if (!isObject(parsed) || !Array.isArray(parsed.memories)) {
-        throw new Error("Memory consolidation returned an invalid JSON shape.");
-    }
-    return parsed;
-}
-function isObject(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-}
+export { RuntimeMemoryConsolidationProvider } from "@lapismd/ai-controller/memory/lapis";

package/dist/memory/types.d.ts

@@ -1,139 +1 @@
-import type { ConversationLocation } from "../conversations/types";
-import type { AgentContextBlock } from "../core/types";
-export type MemoryScope = {
-    kind: "user";
-} | {
-    kind: "workspace";
-} | {
-    kind: "project";
-    projectDir: string;
-};
-export type MemoryOriginClass = "owner" | "agent" | "untrusted" | "system";
-export type MemoryEvidenceRef = {
-    conversationId: string;
-    entryId: string;
-    entryHash: string;
-    observedAt: string;
-    scopeDirAtObservation: string;
-};
-export type DurableMemoryKind = "preference" | "fact" | "decision" | "procedure" | "constraint";
-export type DurableMemoryRecord = {
-    schemaVersion: 1;
-    id: string;
-    revision: number;
-    kind: DurableMemoryKind;
-    scope: MemoryScope;
-    status: "active" | "retracted";
-    supersessionKey?: string;
-    importance: 1 | 2 | 3 | 4 | 5;
-    triggers: string[];
-    summary: string;
-    evidence: MemoryEvidenceRef[];
-    createdBy: "owner-ui" | "deterministic-promotion" | "consolidator";
-    createdAt: string;
-    updatedAt: string;
-    previousRevisionHash?: string;
-};
-export type MemoryContext = {
-    scopeDir: string;
-    conversationId?: string;
-    agentBindingId?: string;
-    runId?: string;
-};
-export type MemorySearchQuery = {
-    query: string;
-    scope?: "current" | "workspace";
-    corpus?: "curated" | "episodic" | "all";
-    limit?: number;
-    since?: string;
-    before?: string;
-    includeSuperseded?: boolean;
-};
-export type MemoryCorpus = "curated" | "episodic";
-export type MemorySearchResult = {
-    ref: string;
-    corpus: MemoryCorpus;
-    snippet: string;
-    kind: DurableMemoryKind | "episode";
-    scope: MemoryScope;
-    observedAt: string;
-    effectiveTrust: MemoryOriginClass;
-    status: "active" | "retracted";
-    score: number;
-    evidence: MemoryEvidenceRef[];
-};
-export type MemoryEvidenceMessage = {
-    id: string;
-    type: "message" | "tool";
-    role?: "user" | "assistant";
-    text: string;
-    observedAt: string;
-    originClass: MemoryOriginClass;
-    hash: string;
-    verification: "matching" | "modified";
-};
-export type MemoryDetail = {
-    ref: string;
-    corpus: MemoryCorpus;
-    status: "available" | "moved" | "missing" | "ambiguous" | "modified";
-    result?: MemorySearchResult;
-    currentLocation?: ConversationLocation;
-    evidenceMessages: MemoryEvidenceMessage[];
-    history?: DurableMemoryRecord[];
-};
-export type MemoryRebuildResult = {
-    conversations: number;
-    episodes: number;
-    skipped: number;
-    inconsistent: number;
-};
-export type ConsolidationPreview = {
-    scope: MemoryScope;
-    candidateIds: string[];
-    proposals: number;
-};
-export type ConsolidationResult = ConsolidationPreview & {
-    written: number;
-    needsReview: number;
-};
-export type MemoryForgetPreview = {
-    conversationId: string;
-    episodeRefs: string[];
-    candidateIds: string[];
-    memoryIds: string[];
-};
-export type MemoryForgetResult = MemoryForgetPreview & {
-    exclusionPath: string;
-    retracted: number;
-    needsReview: number;
-};
-export type GroundedConsolidationInput = {
-    scope: MemoryScope;
-    candidates: Array<{
-        id: string;
-        claim: string;
-        evidence: MemoryEvidenceRef[];
-    }>;
-};
-export type ConsolidationProposal = {
-    memories: Array<Pick<DurableMemoryRecord, "kind" | "scope" | "importance" | "triggers" | "summary"> & {
-        candidateIds: string[];
-        supersessionKey?: string;
-    }>;
-};
-export interface MemoryConsolidationProvider {
-    propose(input: GroundedConsolidationInput, signal?: AbortSignal): Promise<ConsolidationProposal>;
-}
-export interface MemoryService {
-    search(query: MemorySearchQuery, context: MemoryContext, signal?: AbortSignal): Promise<MemorySearchResult[]>;
-    get(ref: string, context: MemoryContext, signal?: AbortSignal): Promise<MemoryDetail>;
-    ingestConversation(location: ConversationLocation): Promise<void>;
-    previewConsolidation(scope: MemoryScope): Promise<ConsolidationPreview>;
-    consolidate(scope: MemoryScope): Promise<ConsolidationResult>;
-    rebuild(scope?: MemoryScope): Promise<MemoryRebuildResult>;
-    previewForgetConversation(location: ConversationLocation): Promise<MemoryForgetPreview>;
-    forgetConversation(location: ConversationLocation): Promise<MemoryForgetResult>;
-}
-export interface AutomaticMemoryRecall {
-    recall(query: string, context: MemoryContext, signal?: AbortSignal): Promise<AgentContextBlock[]>;
-}
+export type { MemoryScope, MemoryOriginClass, MemoryEvidenceRef, DurableMemoryKind, DurableMemoryRecord, MemoryContext, MemorySearchQuery, MemoryCorpus, MemorySearchResult, MemoryEvidenceMessage, MemoryDetail, MemoryRebuildResult, ConsolidationPreview, ConsolidationResult, MemoryForgetPreview, MemoryForgetResult, GroundedConsolidationInput, ConsolidationProposal, MemoryConsolidationProvider, MemoryService, AutomaticMemoryRecall, } from "@lapismd/ai-controller/memory/lapis";

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

@@ -1,10 +1,15 @@
+import type { ControllerConnection } from "../host/controller-connection";
 import type { ModelRef } from "../core/types";
 import type { ModelProvider, ProviderAuthStatus } from "./model-provider";
 export declare class AcpModelProvider implements ModelProvider {
-    #private;
+    readonly options: {
+        connection(): Promise<ControllerConnection>;
+        providerIds?: string[];
+    };
     readonly id: string;
-    constructor(id: string, options?: {
-        workspace?: string;
+    constructor(id: string, options: {
+        connection(): Promise<ControllerConnection>;
+        providerIds?: string[];
     });
     listModels(): Promise<ModelRef[]>;
     authStatus(): Promise<ProviderAuthStatus>;

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

@@ -1,22 +1,31 @@
-import { getNativeDesktopBridge, getNativeDesktopCapability, hasNativeDesktopCapability, } from "@lapis-notes/api/desktop-native";
+import { hasNativeDesktopCapability } from "@lapis-notes/api/desktop-native";
 export class AcpModelProvider {
+    options;
     id;
-    #workspace;
-    constructor(id, options = {}) {
+    constructor(id, options) {
+        this.options = options;
         this.id = id;
-        this.#workspace = options.workspace;
     }
     async listModels() {
         if (!hasNativeDesktopCapability("agent-runtime"))
             return [];
-        const bridge = getNativeDesktopBridge();
-        if (!bridge)
-            return [];
-        const payload = { agent: this.id, workspace: this.#workspace };
-        const catalog = getNativeDesktopCapability("agent-runtime")?.details?.deferredModels ===
-            true
-            ? await deferredModelCatalog(bridge, payload)
-            : await bridge.invoke("desktop_agent_acp_models", payload);
+        const connection = await this.options.connection();
+        let catalog;
+        let firstError;
+        for (const provider of this.options.providerIds ?? [this.id]) {
+            try {
+                const current = await connection.client.request("providers.models", { provider, workspace: connection.workspace });
+                catalog = current;
+                if (current.models?.length)
+                    break;
+            }
+            catch (error) {
+                firstError ??= error;
+            }
+        }
+        if (!catalog && firstError)
+            throw firstError;
+        catalog ??= { agent: this.id, models: [] };
         const current = catalog.currentModel?.trim();
         const entries = new Map((catalog.entries ?? []).map((entry) => [entry.id, entry]));
         return [...new Set(catalog.models ?? [])]
@@ -60,40 +69,3 @@ export class AcpModelProvider {
         }
     }
 }
-async function deferredModelCatalog(bridge, payload) {
-    if (!bridge.onAgentRuntimeEvent) {
-        throw new Error("The desktop agent host cannot deliver model catalogs.");
-    }
-    const requestId = crypto.randomUUID();
-    let unsubscribe = () => { };
-    let timeoutId;
-    const result = new Promise((resolve, reject) => {
-        unsubscribe = bridge.onAgentRuntimeEvent((event) => {
-            if (event.sessionId !== requestId ||
-                event.runId !== "model-catalog" ||
-                event.event.type !== "event") {
-                return;
-            }
-            const detail = event.event.event;
-            if (detail?.type === "model_catalog") {
-                resolve(detail.catalog);
-            }
-            else if (detail?.type === "model_catalog_error") {
-                reject(new Error(String(detail.message ?? "Model discovery failed.")));
-            }
-        });
-        timeoutId = setTimeout(() => reject(new Error("Desktop ACP model discovery timed out.")), 60_000);
-    });
-    try {
-        const started = await bridge.invoke("desktop_agent_acp_models", { ...payload, requestId });
-        if (started.requestId !== requestId) {
-            throw new Error("The desktop agent host returned a different model request id.");
-        }
-        return await result;
-    }
-    finally {
-        if (timeoutId)
-            clearTimeout(timeoutId);
-        unsubscribe();
-    }
-}

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

@@ -10,12 +10,13 @@ export interface ModelProvider {
     authStatus(): Promise<ProviderAuthStatus>;
 }
 export interface AgentModelCatalog {
-    listModels(provider: string): Promise<ModelRef[]>;
+    listModels(provider: string, runtime?: string): Promise<ModelRef[]>;
 }
+export declare function modelCatalogProviderId(provider: string, runtime?: string): string;
 export declare class ModelProviderRegistry implements AgentModelCatalog {
     #private;
     constructor(providers?: ModelProvider[]);
-    listModels(provider: string): Promise<ModelRef[]>;
+    listModels(provider: string, runtime?: string): Promise<ModelRef[]>;
 }
 export declare class StaticModelProvider implements ModelProvider {
     #private;

package/dist/providers/model-provider.js

@@ -1,11 +1,24 @@
+export function modelCatalogProviderId(provider, runtime) {
+    if (provider === "codex" && runtime === "codex-native")
+        return "codex-native";
+    if (provider === "opencode" && runtime === "opencode-native")
+        return "opencode-native";
+    return provider;
+}
 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()) ?? [];
+    async listModels(provider, runtime) {
+        if (runtime === "fake")
+            return [];
+        const id = modelCatalogProviderId(provider, runtime);
+        const models = (await this.#providers.get(id)?.listModels()) ?? [];
+        return id === provider
+            ? models
+            : models.map((model) => ({ ...model, provider }));
     }
 }
 export class StaticModelProvider {

package/dist/runtime-adapters.d.ts

@@ -1,3 +1,6 @@
+export { ControllerConnectionPool } from "./host/controller-connection";
+export type { ControllerConnection } from "./host/controller-connection";
+export { ControllerAgentRuntime } from "./host/controller-runtime";
 export { createAgentProcessHost } from "./host/desktop-process-host";
 export { UnavailableAgentProcessHost } from "./host/process-host";
 export type { AgentProcessHandle, AgentProcessHost, AgentProcessMessage, } from "./host/process-host";

package/dist/runtime-adapters.js

@@ -1,3 +1,5 @@
+export { ControllerConnectionPool } from "./host/controller-connection";
+export { ControllerAgentRuntime } from "./host/controller-runtime";
 export { createAgentProcessHost } from "./host/desktop-process-host";
 export { UnavailableAgentProcessHost } from "./host/process-host";
 export { AcpAgentRuntime } from "./runtimes/acp/acp-runtime";

package/dist/settings/acp-agents.d.ts

@@ -1,8 +1,11 @@
-export declare const ACP_AGENT_IDS: readonly ["codex", "cursor"];
+export declare const ACP_AGENT_IDS: readonly ["codex", "cursor", "opencode"];
 export type AcpAgentId = (typeof ACP_AGENT_IDS)[number];
+export declare const PROCESSOR_AGENT_IDS: readonly ["codex", "cursor"];
+export type ProcessorAgentId = (typeof PROCESSOR_AGENT_IDS)[number];
 export declare const DEFAULT_ACP_AGENT: AcpAgentId;
 export declare function isAcpAgentId(value: unknown): value is AcpAgentId;
 export declare function normalizeAcpAgent(value: unknown): AcpAgentId;
+export declare function normalizeProcessorAgent(value: unknown): ProcessorAgentId;
 export declare function catalogModelsForAgent<T extends {
     provider?: string;
 }>(agent: AcpAgentId, models: T[]): T[];

package/dist/settings/acp-agents.js

@@ -1,4 +1,5 @@
-export const ACP_AGENT_IDS = ["codex", "cursor"];
+export const ACP_AGENT_IDS = ["codex", "cursor", "opencode"];
+export const PROCESSOR_AGENT_IDS = ["codex", "cursor"];
 export const DEFAULT_ACP_AGENT = "codex";
 export function isAcpAgentId(value) {
     return ACP_AGENT_IDS.some((id) => id === value);
@@ -6,6 +7,9 @@ export function isAcpAgentId(value) {
 export function normalizeAcpAgent(value) {
     return isAcpAgentId(value) ? value : DEFAULT_ACP_AGENT;
 }
+export function normalizeProcessorAgent(value) {
+    return PROCESSOR_AGENT_IDS.find((id) => id === value) ?? "codex";
+}
 export function catalogModelsForAgent(agent, models) {
     return models.filter((model) => model.provider === agent || !model.provider);
 }

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

@@ -1,10 +1,11 @@
 import { PluginSettingTab, Setting, } from "@lapis-notes/api";
-import { ACP_AGENT_IDS } from "./acp-agents";
+import { ACP_AGENT_IDS, PROCESSOR_AGENT_IDS, normalizeProcessorAgent, } from "./acp-agents";
 import { applyAppToolEnablement } from "./ai-settings";
 import { listAppToolSettingRows, registeredAppToolRefs, } from "./app-tool-setting-rows";
 const ACP_AGENT_LABELS = {
     codex: "Codex",
     cursor: "Cursor",
+    opencode: "OpenCode",
 };
 const THINKING_OPTIONS = [
     { id: "off", label: "Off" },
@@ -34,6 +35,7 @@ export class AiSettingsTab extends PluginSettingTab {
                 .addOption("auto", "Automatic")
                 .addOption("acp", "ACP")
                 .addOption("codex-native", "Codex native")
+                .addOption("opencode-native", "OpenCode native")
                 .addOption("fake", "Fake (tests)")
                 .setValue(settings.defaultRuntime)
                 .onChange((value) => {
@@ -122,14 +124,14 @@ export class AiSettingsTab extends PluginSettingTab {
             .setName("Memory processor agent")
             .setDesc("Pinned independently from the interactive chat agent.")
             .addDropdown((dropdown) => {
-            for (const id of ACP_AGENT_IDS) {
+            for (const id of PROCESSOR_AGENT_IDS) {
                 dropdown.addOption(id, ACP_AGENT_LABELS[id]);
             }
             dropdown
                 .setValue(settings.memoryConsolidationAgent)
                 .onChange((value) => {
                 void this.aiPlugin.updateSettings({
-                    memoryConsolidationAgent: value,
+                    memoryConsolidationAgent: normalizeProcessorAgent(value),
                 });
             });
         });
@@ -171,12 +173,12 @@ export class AiSettingsTab extends PluginSettingTab {
             .setName("Handoff summary agent")
             .setDesc("Pinned independently from the interactive chat agent.")
             .addDropdown((dropdown) => {
-            for (const id of ACP_AGENT_IDS) {
+            for (const id of PROCESSOR_AGENT_IDS) {
                 dropdown.addOption(id, ACP_AGENT_LABELS[id]);
             }
             dropdown.setValue(settings.handoffSummaryAgent).onChange((value) => {
                 void this.aiPlugin.updateSettings({
-                    handoffSummaryAgent: value,
+                    handoffSummaryAgent: normalizeProcessorAgent(value),
                 });
             });
         });
@@ -214,7 +216,7 @@ export class AiSettingsTab extends PluginSettingTab {
     }
     async loadModels(dropdown, settings, setting) {
         try {
-            const models = await this.aiPlugin.models.listModels(settings.acpAgent);
+            const models = await this.aiPlugin.models.listModels(settings.acpAgent, settings.defaultRuntime);
             if (models.length === 0) {
                 setting.setDesc(`The ${settings.acpAgent} provider returned no model catalog; keeping the saved selection.`);
                 dropdown.setDisabled(false);