@lapis-notes/ai 0.1.0

package/dist/runtimes/codex/app-server-protocol.js

@@ -0,0 +1,274 @@
+import { DEFAULT_APPROVAL_OPTIONS, } from "../../core/types";
+function asRecord(value) {
+    return value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : {};
+}
+function stringValue(value) {
+    return typeof value === "string" ? value : undefined;
+}
+function numberValue(value) {
+    return typeof value === "number" && Number.isFinite(value)
+        ? value
+        : undefined;
+}
+function streamedText(value) {
+    if (typeof value === "string")
+        return value;
+    const record = asRecord(value);
+    for (const key of ["text", "delta", "content", "message", "value"]) {
+        const candidate = record[key];
+        if (typeof candidate === "string")
+            return candidate;
+    }
+    return "";
+}
+function isToolItem(item) {
+    return [
+        "mcpToolCall",
+        "dynamicToolCall",
+        "commandExecution",
+        "fileChange",
+    ].includes(String(item.type ?? ""));
+}
+function toolName(item) {
+    if (item.type === "commandExecution")
+        return "command";
+    if (item.type === "fileChange")
+        return "file change";
+    return String(item.tool ?? item.command ?? item.type ?? "tool");
+}
+function toolInput(item) {
+    return item.command ?? item.arguments ?? item.input ?? item.changes;
+}
+export function mapCodexNotification(message) {
+    const params = asRecord(message.params);
+    const item = asRecord(params.item);
+    const method = message.method ?? "";
+    if (method === "item/agentMessage/delta" ||
+        method === "turn/agentMessage/delta") {
+        const text = streamedText(params.delta ?? params.text);
+        return text ? { type: "text", text } : null;
+    }
+    if (method === "item/reasoning/textDelta" ||
+        method === "item/reasoning/delta" ||
+        method === "turn/reasoning/delta") {
+        const text = streamedText(params.delta ?? params.text);
+        return text ? { type: "thinking", text, kind: "reasoning" } : null;
+    }
+    if (method === "item/reasoning/summaryTextDelta") {
+        const text = streamedText(params.delta ?? params.text);
+        return text ? { type: "thinking", text, kind: "summary" } : null;
+    }
+    if (method === "item/plan/delta") {
+        const text = streamedText(params.delta ?? params.text);
+        return text ? { type: "thinking", text, kind: "plan" } : null;
+    }
+    if (method === "thread/tokenUsage/updated") {
+        const tokenUsage = asRecord(params.tokenUsage);
+        const total = asRecord(tokenUsage.total);
+        const used = numberValue(total.totalTokens);
+        const limit = numberValue(tokenUsage.modelContextWindow);
+        return used !== undefined && used >= 0 && limit !== undefined && limit > 0
+            ? { type: "usage", usage: { used, limit } }
+            : null;
+    }
+    if (method === "item/started" || method === "item/toolCall/started") {
+        if (!isToolItem(item) && method !== "item/toolCall/started")
+            return null;
+        return {
+            type: "tool.start",
+            id: String(item.id ?? params.itemId ?? "codex-tool"),
+            name: toolName(item),
+            server: stringValue(item.server),
+            input: toolInput(item),
+        };
+    }
+    if (method === "item/completed") {
+        if (isToolItem(item)) {
+            return {
+                type: "tool.end",
+                id: String(item.id ?? params.itemId ?? "codex-tool"),
+                name: toolName(item),
+                server: stringValue(item.server),
+                output: item.result ??
+                    item.aggregatedOutput ??
+                    item.contentItems ??
+                    item.output,
+                error: item.error,
+            };
+        }
+        return null;
+    }
+    if (method === "turn/completed") {
+        const turn = asRecord(params.turn);
+        if (turn.status === "failed") {
+            const error = asRecord(turn.error);
+            return {
+                type: "error",
+                error: new Error(stringValue(error.message) ?? "Codex turn failed"),
+            };
+        }
+        return { type: "completed", result: params };
+    }
+    if (method === "warning" ||
+        method === "guardianWarning" ||
+        method === "configWarning" ||
+        method === "deprecationNotice") {
+        return {
+            type: "status",
+            status: String(params.message ?? params.warning ?? "Codex warning"),
+        };
+    }
+    if (method === "error" || message.error) {
+        const record = asRecord(message.error);
+        const paramsError = asRecord(params.error);
+        return {
+            type: "error",
+            error: new Error(stringValue(record.message) ??
+                stringValue(params.message) ??
+                stringValue(paramsError.message) ??
+                "Codex app-server error"),
+        };
+    }
+    return null;
+}
+export function approvalRequestFromServerRequest(message) {
+    if (message.id === undefined || !message.method)
+        return null;
+    const request = asRecord(message.params);
+    const method = message.method;
+    if (![
+        "item/commandExecution/requestApproval",
+        "item/fileChange/requestApproval",
+        "item/permissions/requestApproval",
+        "applyPatchApproval",
+        "execCommandApproval",
+    ].includes(method)) {
+        return null;
+    }
+    const kind = mapCodexApprovalKind(method.includes("command") || method === "execCommandApproval"
+        ? "command"
+        : method.includes("file") || method === "applyPatchApproval"
+            ? "file_change"
+            : "permissions");
+    return {
+        id: String(message.id),
+        origin: "runtime",
+        kind,
+        title: stringValue(request.reason) ??
+            stringValue(request.header) ??
+            "Allow this Codex action?",
+        tool: request.command
+            ? { name: "command", input: request.command }
+            : undefined,
+        options: DEFAULT_APPROVAL_OPTIONS,
+    };
+}
+export function userInputRequestFromServerRequest(message) {
+    if (message.id === undefined ||
+        message.method !== "item/tool/requestUserInput") {
+        return null;
+    }
+    const params = asRecord(message.params);
+    const questions = Array.isArray(params.questions)
+        ? params.questions.flatMap((value, questionIndex) => {
+            const question = asRecord(value);
+            const id = stringValue(question.id);
+            const prompt = stringValue(question.question);
+            if (!id || !prompt)
+                return [];
+            const rawOptions = Array.isArray(question.options)
+                ? question.options
+                : [];
+            const options = rawOptions.flatMap((optionValue, optionIndex) => {
+                const option = asRecord(optionValue);
+                const label = stringValue(option.label);
+                if (!label)
+                    return [];
+                return [
+                    {
+                        id: `${id}-option-${optionIndex + 1}`,
+                        label,
+                        description: stringValue(option.description),
+                    },
+                ];
+            });
+            return [
+                {
+                    id,
+                    header: stringValue(question.header) ?? `Question ${questionIndex + 1}`,
+                    prompt,
+                    options: options.length > 0 ? options : undefined,
+                    allowOther: question.isOther === true,
+                    secret: question.isSecret === true,
+                },
+            ];
+        })
+        : [];
+    if (questions.length === 0)
+        return null;
+    return {
+        id: String(message.id),
+        title: "Agent needs input",
+        questions,
+    };
+}
+export function userInputReplyForServerRequest(message, answers) {
+    if (message.method !== "item/tool/requestUserInput") {
+        return { error: { code: -32601, message: "Unsupported input request" } };
+    }
+    return {
+        result: {
+            answers: Object.fromEntries(Object.entries(answers).map(([id, values]) => [
+                id,
+                { answers: [...values] },
+            ])),
+        },
+    };
+}
+export function approvalResponseForOption(optionId) {
+    if (optionId === "allow-always")
+        return { decision: "acceptForSession" };
+    if (optionId === "deny-once" || optionId === "deny-always") {
+        return { decision: "decline" };
+    }
+    return { decision: "accept" };
+}
+export function approvalReplyForServerRequest(message, optionId) {
+    if (message.method === "item/permissions/requestApproval") {
+        if (optionId.startsWith("deny")) {
+            return {
+                error: { code: -32000, message: "Permission request declined" },
+            };
+        }
+        const params = asRecord(message.params);
+        return {
+            result: {
+                permissions: params.permissions ?? {},
+                scope: optionId === "allow-always" ? "session" : "turn",
+            },
+        };
+    }
+    if (message.method === "applyPatchApproval" ||
+        message.method === "execCommandApproval") {
+        return {
+            result: {
+                decision: optionId.startsWith("deny") ? "denied" : "approved",
+            },
+        };
+    }
+    return { result: approvalResponseForOption(optionId) };
+}
+function mapCodexApprovalKind(kind) {
+    if (kind === "command" || kind === "execute")
+        return "execute";
+    if (kind === "file_change" || kind === "apply_patch" || kind === "write") {
+        return "write";
+    }
+    if (kind === "permissions" || kind === "network")
+        return "network";
+    if (kind === "read")
+        return "read";
+    return "other";
+}

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

@@ -0,0 +1,24 @@
+import { type AgentCapabilities, type AgentEvent, type AgentRequest, type AgentRuntime, type AgentSession, type AgentSessionConfiguration, type AgentSessionConfigurationResult, type AgentTurnOptions, type UserInputAnswers } from "../../core/types";
+import type { AgentProcessHandle, AgentProcessHost } from "../../host/process-host";
+export declare class CodexNativeSession implements AgentSession {
+    #private;
+    constructor(process: AgentProcessHandle, request: Omit<AgentRequest, "prompt">);
+    get id(): string;
+    initialize(resumeThreadId?: string): Promise<void>;
+    events(): AsyncIterable<AgentEvent>;
+    send(input: string, options?: AgentTurnOptions): Promise<void>;
+    configure(input: AgentSessionConfiguration): Promise<AgentSessionConfigurationResult>;
+    respondToApproval(requestId: string, optionId: string): Promise<void>;
+    respondToQuestion(requestId: string, answers: UserInputAnswers): Promise<void>;
+    cancel(): Promise<void>;
+    close(): Promise<void>;
+}
+export declare class CodexNativeRuntime implements AgentRuntime {
+    #private;
+    readonly id = "codex-native";
+    constructor(host: AgentProcessHost);
+    capabilities(): AgentCapabilities;
+    supports(request: AgentRequest): Promise<boolean>;
+    start(request: AgentRequest): Promise<AgentSession>;
+    resume(sessionId: string, request?: Omit<AgentRequest, "prompt">): Promise<AgentSession>;
+}

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

@@ -0,0 +1,318 @@
+import { AsyncEventQueue } from "../../core/event-queue";
+import { NATIVE_CODEX_APPROVAL_CAPABILITIES, projectAgentTurnPrompt, } from "../../core/types";
+import { approvalReplyForServerRequest, approvalRequestFromServerRequest, mapCodexNotification, userInputReplyForServerRequest, userInputRequestFromServerRequest, } from "./app-server-protocol";
+export class CodexNativeSession {
+    #process;
+    #request;
+    #events = new AsyncEventQueue();
+    #pending = new Map();
+    #pendingServerRequests = new Map();
+    #buffer = "";
+    #rpcId = 1;
+    #threadId = null;
+    #activeTurnId = null;
+    #closed = false;
+    #consume;
+    constructor(process, request) {
+        this.#process = process;
+        this.#request = request;
+        this.#consume = this.#pump();
+    }
+    get id() {
+        return this.#threadId ?? `codex-${this.#process.id}`;
+    }
+    async initialize(resumeThreadId) {
+        await this.#requestRpc("initialize", {
+            clientInfo: {
+                name: "lapis_notes_ai",
+                title: "Lapis Notes AI",
+                version: "0.0.1",
+            },
+            capabilities: { experimentalApi: true },
+        });
+        await this.#notify("initialized", {});
+        const workspace = this.#request.workspace;
+        const common = {
+            model: this.#request.model?.model ?? null,
+            cwd: workspace ?? null,
+            runtimeWorkspaceRoots: workspace ? [workspace] : null,
+            approvalPolicy: this.#request.restricted ? "never" : "on-request",
+            sandbox: "read-only",
+        };
+        const response = (await this.#requestRpc(resumeThreadId ? "thread/resume" : "thread/start", resumeThreadId
+            ? { threadId: resumeThreadId, ...common }
+            : { ...common, ephemeral: false }));
+        const threadId = response.thread?.id ?? resumeThreadId;
+        if (!threadId)
+            throw new Error("Codex did not return a thread id.");
+        this.#threadId = threadId;
+    }
+    events() {
+        return this.#events;
+    }
+    async send(input, options) {
+        if (!this.#threadId)
+            throw new Error("Codex session has not initialized.");
+        const response = (await this.#requestRpc("turn/start", {
+            threadId: this.#threadId,
+            input: [
+                {
+                    type: "text",
+                    text: projectAgentTurnPrompt(input, options?.contextBlocks),
+                    text_elements: [],
+                },
+            ],
+            ...(this.#request.workspace
+                ? {
+                    cwd: this.#request.workspace,
+                    runtimeWorkspaceRoots: [this.#request.workspace],
+                }
+                : {}),
+            approvalPolicy: this.#request.restricted ? "never" : "on-request",
+            sandboxPolicy: { type: "readOnly", networkAccess: false },
+            ...(this.#request.model?.model
+                ? { model: this.#request.model.model }
+                : {}),
+            ...(thinkingEffort(this.#request.thinking)
+                ? { effort: thinkingEffort(this.#request.thinking) }
+                : {}),
+        }));
+        this.#activeTurnId = response.turn?.id ?? this.#activeTurnId;
+    }
+    async configure(input) {
+        this.#request = {
+            ...this.#request,
+            ...(input.model ? { model: { ...input.model } } : {}),
+            ...(input.thinking ? { thinking: input.thinking } : {}),
+        };
+        return {
+            ...(input.model ? { model: { status: "applied" } } : {}),
+            ...(input.thinking ? { thinking: { status: "applied" } } : {}),
+        };
+    }
+    async respondToApproval(requestId, optionId) {
+        const pending = this.#pendingServerRequests.get(requestId);
+        if (!pending)
+            throw new Error(`Unknown Codex approval request: ${requestId}`);
+        this.#pendingServerRequests.delete(requestId);
+        const reply = approvalReplyForServerRequest(pending, optionId);
+        await this.#write({ id: pending.id, ...reply });
+    }
+    async respondToQuestion(requestId, answers) {
+        const pending = this.#pendingServerRequests.get(requestId);
+        if (!pending || pending.method !== "item/tool/requestUserInput") {
+            throw new Error(`Unknown Codex user-input request: ${requestId}`);
+        }
+        this.#pendingServerRequests.delete(requestId);
+        const reply = userInputReplyForServerRequest(pending, answers);
+        await this.#write({ id: pending.id, ...reply });
+    }
+    async cancel() {
+        if (!this.#threadId)
+            return;
+        try {
+            await this.#requestRpc("turn/interrupt", {
+                threadId: this.#threadId,
+                turnId: this.#activeTurnId ?? undefined,
+            });
+        }
+        catch {
+            // Cancellation is intentionally idempotent for the UI.
+        }
+        this.#events.push({ type: "status", status: "cancelled" });
+    }
+    async close() {
+        if (this.#closed)
+            return;
+        this.#closed = true;
+        this.#rejectAll(new Error("Codex session closed."));
+        this.#pendingServerRequests.clear();
+        await this.#process.kill();
+        await this.#consume;
+        this.#events.close();
+    }
+    async #pump() {
+        try {
+            for await (const message of this.#process.messages()) {
+                if (message.type === "stderr")
+                    continue;
+                if (message.type === "exit") {
+                    if (!this.#closed) {
+                        const error = new Error(`Codex app-server exited with code ${message.exitCode}.`);
+                        this.#events.push({ type: "error", error });
+                        this.#rejectAll(error);
+                    }
+                    break;
+                }
+                this.#buffer += message.data;
+                const lines = this.#buffer.split("\n");
+                this.#buffer = lines.pop() ?? "";
+                for (const line of lines) {
+                    if (line.trim())
+                        this.#handleLine(line);
+                }
+            }
+        }
+        catch (error) {
+            const normalized = error instanceof Error ? error : new Error(String(error));
+            this.#events.push({ type: "error", error: normalized });
+            this.#rejectAll(normalized);
+        }
+        finally {
+            if (!this.#closed)
+                this.#events.close();
+        }
+    }
+    #handleLine(line) {
+        let parsed;
+        try {
+            parsed = JSON.parse(line);
+        }
+        catch {
+            this.#events.push({
+                type: "error",
+                error: new Error("Codex app-server returned invalid JSONL."),
+            });
+            return;
+        }
+        if (parsed.id !== undefined && !parsed.method) {
+            const pending = this.#pending.get(parsed.id);
+            if (!pending)
+                return;
+            this.#pending.delete(parsed.id);
+            if (parsed.error) {
+                const error = parsed.error;
+                pending.reject(new Error(String(error.message ?? "Codex request failed")));
+            }
+            else {
+                pending.resolve(parsed.result);
+            }
+            return;
+        }
+        const approval = approvalRequestFromServerRequest(parsed);
+        if (approval && parsed.id !== undefined) {
+            this.#pendingServerRequests.set(approval.id, parsed);
+            this.#events.push({ type: "permission.request", request: approval });
+            return;
+        }
+        const question = userInputRequestFromServerRequest(parsed);
+        if (question && parsed.id !== undefined) {
+            this.#pendingServerRequests.set(question.id, parsed);
+            this.#events.push({ type: "question.request", request: question });
+            return;
+        }
+        const event = mapCodexNotification(parsed);
+        if (!event)
+            return;
+        if (event.type === "completed" || event.type === "error") {
+            this.#activeTurnId = null;
+        }
+        this.#events.push(event);
+    }
+    async #requestRpc(method, params) {
+        const id = this.#rpcId++;
+        const result = new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.#pending.delete(id);
+                reject(new Error(`Codex ${method} request timed out.`));
+            }, 15_000);
+            this.#pending.set(id, {
+                resolve(value) {
+                    clearTimeout(timer);
+                    resolve(value);
+                },
+                reject(error) {
+                    clearTimeout(timer);
+                    reject(error);
+                },
+            });
+        });
+        try {
+            await this.#write({ id, method, params });
+        }
+        catch (error) {
+            const normalized = error instanceof Error ? error : new Error(String(error));
+            this.#pending.get(id)?.reject(normalized);
+            this.#pending.delete(id);
+            return result;
+        }
+        return result;
+    }
+    async #notify(method, params) {
+        await this.#write({ method, params });
+    }
+    async #write(message) {
+        await this.#process.write(`${JSON.stringify(message)}\n`);
+    }
+    #rejectAll(error) {
+        for (const [id, pending] of this.#pending) {
+            this.#pending.delete(id);
+            pending.reject(error);
+        }
+    }
+}
+export class CodexNativeRuntime {
+    id = "codex-native";
+    #host;
+    constructor(host) {
+        this.#host = host;
+    }
+    capabilities() {
+        return {
+            sessions: true,
+            resume: true,
+            cancel: true,
+            steer: false,
+            modelSelection: true,
+            nativeTools: true,
+            mcpTools: true,
+            approvals: NATIVE_CODEX_APPROVAL_CAPABILITIES,
+        };
+    }
+    async supports(request) {
+        return this.#host.available && request.agent !== "cursor";
+    }
+    async start(request) {
+        return this.#open(request);
+    }
+    async resume(sessionId, request = {}) {
+        return this.#open({ ...request, prompt: "" }, sessionId);
+    }
+    async #open(request, resumeThreadId) {
+        const process = await this.#host.spawn({
+            command: "codex",
+            args: codexArgsFor(request.mcpServers),
+            cwd: request.workspace,
+            appToolBridgeId: request.appToolSession?.bridgeId,
+        });
+        const session = new CodexNativeSession(process, request);
+        try {
+            await session.initialize(resumeThreadId);
+            return session;
+        }
+        catch (error) {
+            await session.close();
+            throw error;
+        }
+    }
+}
+function thinkingEffort(thinking) {
+    return thinking === "off" ? "none" : thinking;
+}
+function codexArgsFor(mcpServers) {
+    const args = ["app-server", "--stdio"];
+    for (const server of mcpServers ?? []) {
+        const prefix = `mcp_servers.${server.name}`;
+        args.push("-c", `${prefix}.command=${JSON.stringify(server.command)}`);
+        if (server.args) {
+            args.push("-c", `${prefix}.args=${JSON.stringify(server.args)}`);
+        }
+        if (server.cwd) {
+            args.push("-c", `${prefix}.cwd=${JSON.stringify(server.cwd)}`);
+        }
+        if (server.enabledTools) {
+            args.push("-c", `${prefix}.enabled_tools=${JSON.stringify(server.enabledTools)}`);
+        }
+    }
+    return args;
+}

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

@@ -0,0 +1,51 @@
+import { type AgentCapabilities, type AgentEvent, type AgentRequest, type AgentRuntime, type AgentSession, type AgentSessionConfiguration, type AgentSessionConfigurationResult, type AgentTurnOptions, type UserInputAnswers } from "../../core/types";
+import type { NativeAgentCommand } from "../../skills/types";
+export type FakeAgentTrace = "echo" | "rich";
+export type FakeAgentRuntimeOptions = {
+    id?: string;
+    requireApproval?: boolean;
+    requireQuestion?: boolean;
+    resumeSupported?: boolean;
+    trace?: FakeAgentTrace;
+    nativeCommands?: NativeAgentCommand[];
+};
+export declare const FAKE_RICH_THINKING = "I will read the mentioned note, then summarize it.";
+export declare const FAKE_RICH_TOOL: {
+    readonly id: "tool-vault-read";
+    readonly name: "vault.read";
+    readonly input: {
+        readonly path: "Notes/alpha.md";
+    };
+    readonly output: "heading: Notes";
+};
+export declare const FAKE_RICH_ASSISTANT_TEXT: string;
+export declare class FakeAgentSession implements AgentSession {
+    #private;
+    readonly id: string;
+    readonly prompts: string[];
+    readonly contextBlocks: AgentTurnOptions["contextBlocks"][];
+    readonly configurations: AgentSessionConfiguration[];
+    cancelled: boolean;
+    closed: boolean;
+    detached: boolean;
+    constructor(id: string, requireApproval: boolean, trace?: FakeAgentTrace, requireQuestion?: boolean, nativeCommands?: NativeAgentCommand[]);
+    events(): AsyncIterable<AgentEvent>;
+    send(input: string, options?: AgentTurnOptions): Promise<void>;
+    configure(input: AgentSessionConfiguration): Promise<AgentSessionConfigurationResult>;
+    respondToApproval(requestId: string, optionId: string): Promise<void>;
+    respondToQuestion(requestId: string, answers: UserInputAnswers): Promise<void>;
+    cancel(): Promise<void>;
+    close(): Promise<void>;
+    detach(): Promise<void>;
+}
+export declare class FakeAgentRuntime implements AgentRuntime {
+    #private;
+    readonly id: string;
+    readonly sessions: FakeAgentSession[];
+    lastRequest: AgentRequest | null;
+    constructor(options?: FakeAgentRuntimeOptions);
+    capabilities(): AgentCapabilities;
+    supports(request: AgentRequest): Promise<boolean>;
+    start(request: AgentRequest): Promise<AgentSession>;
+    resume(sessionId: string): Promise<AgentSession>;
+}