@lapis-notes/ai 0.1.0

package/dist/memory/paths.d.ts

@@ -0,0 +1,13 @@
+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;

package/dist/memory/paths.js

@@ -0,0 +1,60 @@
+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);
+}

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

@@ -0,0 +1,18 @@
+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>;
+}

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

@@ -0,0 +1,154 @@
+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);
+}

package/dist/memory/types.d.ts

@@ -0,0 +1,139 @@
+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[]>;
+}

package/dist/memory/types.js

@@ -0,0 +1 @@
+export {};

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

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

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

@@ -0,0 +1,99 @@
+import { getNativeDesktopBridge, getNativeDesktopCapability, hasNativeDesktopCapability, } from "@lapis-notes/api/desktop-native";
+export class AcpModelProvider {
+    id;
+    #workspace;
+    constructor(id, 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 current = catalog.currentModel?.trim();
+        const entries = new Map((catalog.entries ?? []).map((entry) => [entry.id, entry]));
+        return [...new Set(catalog.models ?? [])]
+            .map((model) => model.trim())
+            .filter(Boolean)
+            .map((model) => {
+            const entry = entries.get(model);
+            return {
+                provider: this.id,
+                model,
+                ...(entry?.label ? { displayName: entry.label } : {}),
+                ...(entry?.badges?.length ? { badges: entry.badges } : {}),
+                isDefault: model === current,
+            };
+        });
+    }
+    async authStatus() {
+        if (!hasNativeDesktopCapability("agent-runtime")) {
+            return {
+                authenticated: false,
+                label: this.id,
+                detail: "Live model listing requires the desktop agent-runtime capability.",
+            };
+        }
+        try {
+            const models = await this.listModels();
+            return models.length > 0
+                ? { authenticated: true, label: this.id }
+                : {
+                    authenticated: false,
+                    label: this.id,
+                    detail: `${this.id} did not return a model catalog.`,
+                };
+        }
+        catch (error) {
+            return {
+                authenticated: false,
+                label: this.id,
+                detail: error instanceof Error ? error.message : String(error),
+            };
+        }
+    }
+}
+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/codex-model-catalog.d.ts

@@ -0,0 +1,7 @@
+import type { ModelRef } from "../core/types";
+import type { AgentProcessHost } from "../host/process-host";
+export declare function normalizeCodexModelList(result: unknown): ModelRef[];
+export declare function listCodexModelsFromHost(host: AgentProcessHost, options?: {
+    cwd?: string;
+    timeoutMs?: number;
+}): Promise<ModelRef[]>;

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

@@ -0,0 +1,179 @@
+function asRecord(value) {
+    return value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : {};
+}
+function stringValue(value) {
+    return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+function withTimeout(promise, timeoutMs, message) {
+    return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => reject(new Error(message)), timeoutMs);
+        promise.then((value) => {
+            clearTimeout(timer);
+            resolve(value);
+        }, (error) => {
+            clearTimeout(timer);
+            reject(error);
+        });
+    });
+}
+export function normalizeCodexModelList(result) {
+    const data = asRecord(result).data;
+    if (!Array.isArray(data))
+        return [];
+    const models = [];
+    const seen = new Set();
+    for (const entry of data) {
+        const record = asRecord(entry);
+        const model = stringValue(record.model) ?? stringValue(record.id);
+        if (!model || seen.has(model))
+            continue;
+        seen.add(model);
+        const supportedThinking = Array.isArray(record.supportedReasoningEfforts)
+            ? record.supportedReasoningEfforts
+                .map((option) => {
+                const effort = stringValue(asRecord(option).reasoningEffort);
+                if (effort === "none")
+                    return "off";
+                if (effort === "low" || effort === "medium" || effort === "high") {
+                    return effort;
+                }
+                return undefined;
+            })
+                .filter((value) => value !== undefined)
+            : undefined;
+        const displayName = stringValue(record.displayName);
+        const description = stringValue(record.description);
+        models.push({
+            provider: "codex",
+            model,
+            ...(displayName ? { displayName } : {}),
+            ...(description ? { description } : {}),
+            ...(record.isDefault === true ? { isDefault: true } : {}),
+            ...(supportedThinking && supportedThinking.length > 0
+                ? { supportedThinking: [...new Set(supportedThinking)] }
+                : {}),
+        });
+    }
+    return models;
+}
+export async function listCodexModelsFromHost(host, options = {}) {
+    if (!host.available)
+        return [];
+    const timeoutMs = options.timeoutMs ?? 10_000;
+    const process = await withTimeout(host.spawn({
+        command: "codex",
+        args: ["app-server", "--stdio"],
+        cwd: options.cwd,
+    }), timeoutMs, "Codex model catalog spawn timed out");
+    const rpc = new CodexCatalogRpc(process);
+    try {
+        return await withTimeout((async () => {
+            await rpc.request("initialize", {
+                clientInfo: {
+                    name: "lapis_ai_model_catalog",
+                    title: "Lapis AI Model Catalog",
+                    version: "0.0.1",
+                },
+                capabilities: {},
+            });
+            await rpc.notify("initialized", {});
+            const models = [];
+            let cursor = null;
+            const seenCursors = new Set();
+            do {
+                const result = await rpc.request("model/list", {
+                    limit: 100,
+                    includeHidden: false,
+                    ...(cursor ? { cursor } : {}),
+                });
+                models.push(...normalizeCodexModelList(result));
+                const nextCursor = stringValue(asRecord(result).nextCursor) ?? null;
+                if (!nextCursor || seenCursors.has(nextCursor))
+                    break;
+                seenCursors.add(nextCursor);
+                cursor = nextCursor;
+            } while (cursor);
+            return models;
+        })(), timeoutMs, "Codex model catalog request timed out");
+    }
+    finally {
+        await rpc.close();
+    }
+}
+class CodexCatalogRpc {
+    process;
+    #id = 1;
+    #buffer = "";
+    #pending = new Map();
+    #consume;
+    constructor(process) {
+        this.process = process;
+        this.#consume = this.#pump();
+    }
+    async request(method, params) {
+        const id = this.#id++;
+        const result = new Promise((resolve, reject) => {
+            this.#pending.set(id, { resolve, reject });
+        });
+        try {
+            await this.process.write(`${JSON.stringify({ id, method, params })}\n`);
+        }
+        catch (error) {
+            this.#pending.delete(id);
+            throw error;
+        }
+        return result;
+    }
+    async notify(method, params) {
+        await this.process.write(`${JSON.stringify({ method, params })}\n`);
+    }
+    async close() {
+        for (const [id, pending] of this.#pending) {
+            this.#pending.delete(id);
+            pending.reject(new Error("Codex model catalog closed."));
+        }
+        await this.process.kill();
+        await this.#consume;
+    }
+    async #pump() {
+        try {
+            for await (const message of this.process.messages()) {
+                if (message.type !== "stdout")
+                    continue;
+                this.#buffer += message.data;
+                const lines = this.#buffer.split("\n");
+                this.#buffer = lines.pop() ?? "";
+                for (const line of lines)
+                    this.#handleLine(line);
+            }
+        }
+        catch {
+            /* process closed */
+        }
+    }
+    #handleLine(line) {
+        if (!line.trim())
+            return;
+        let parsed;
+        try {
+            parsed = JSON.parse(line);
+        }
+        catch {
+            return;
+        }
+        if (parsed.id === undefined || parsed.method)
+            return;
+        const pending = this.#pending.get(Number(parsed.id));
+        if (!pending)
+            return;
+        this.#pending.delete(Number(parsed.id));
+        if (parsed.error) {
+            const record = asRecord(parsed.error);
+            pending.reject(new Error(stringValue(record.message) ?? "Codex model/list failed"));
+            return;
+        }
+        pending.resolve(parsed.result);
+    }
+}