@lapis-notes/ai 0.1.1 → 0.1.5

package/dist/host/controller-runtime.js

@@ -0,0 +1,112 @@
+import { ControllerRuntime, } from "@lapismd/ai-controller/runtime";
+import { projectSkillActivationPrompt } from "../skills/activation";
+/** Lapis supplies domain instructions and endpoint identities; the SDK owns execution. */
+export class ControllerAgentRuntime {
+    id;
+    connections;
+    #runtimes = new WeakMap();
+    #last;
+    constructor(id, connections) {
+        this.id = id;
+        this.connections = connections;
+    }
+    capabilities() {
+        return (this.#last?.capabilities() ?? {
+            sessions: true,
+            resume: true,
+            cancel: true,
+            steer: false,
+            modelSelection: false,
+            nativeTools: true,
+            mcpTools: false,
+            preparesContext: true,
+            approvals: {
+                supported: false,
+                interactive: false,
+                persistentDecisions: false,
+                granularPermissions: false,
+                policyAmendments: false,
+            },
+        });
+    }
+    async supports(request) {
+        try {
+            return await (await this.#runtime(request)).supports(request);
+        }
+        catch {
+            return false;
+        }
+    }
+    async start(request) {
+        return (await this.#runtime(request)).start(request);
+    }
+    async resume(id, request = {}) {
+        return (await this.#runtime(request)).resume(id, request);
+    }
+    async #runtime(request) {
+        const connection = await this.connections.get(request.workspace);
+        let runtime = this.#runtimes.get(connection);
+        if (!runtime) {
+            runtime = new ControllerRuntime({
+                id: this.id,
+                client: connection.client,
+                provider: (request) => this.id === "codex-native"
+                    ? "codex-native"
+                    : this.id === "opencode-native"
+                        ? "opencode-native"
+                        : request.agent ?? "codex",
+                workspace: () => connection.workspace,
+                prepare: async (request, threadId) => {
+                    const contextId = `lapis.instructions.${threadId}`;
+                    const bootstrap = typeof request.metadata?.sessionBootstrap === "string"
+                        ? request.metadata.sessionBootstrap
+                        : "";
+                    let activation = projectSkillActivationPrompt("", request.skillActivations).trim();
+                    return {
+                        thread: {
+                            contextSources: [contextId],
+                            ...(request.appToolSession?.bridgeId
+                                ? { toolEndpoint: request.appToolSession.bridgeId }
+                                : {}),
+                            ...(request.appToolSession?.conversationId
+                                ? { externalRef: request.appToolSession.conversationId }
+                                : {}),
+                        },
+                        endpoints: [
+                            {
+                                id: contextId,
+                                context: true,
+                                required: true,
+                                handle: async (call) => {
+                                    if (call.operation === "context.authorize")
+                                        return true;
+                                    if (call.operation !== "context.resolve")
+                                        throw new Error("Unsupported instruction request.");
+                                    const instructions = [bootstrap, activation]
+                                        .filter(Boolean)
+                                        .join("\n\n");
+                                    activation = "";
+                                    return (instructions
+                                        ? [
+                                            {
+                                                id: contextId,
+                                                revision: "1",
+                                                kind: "instructions",
+                                                trust: "instructions",
+                                                required: true,
+                                                content: instructions,
+                                            },
+                                        ]
+                                        : []);
+                                },
+                            },
+                        ],
+                    };
+                },
+            });
+            this.#runtimes.set(connection, runtime);
+        }
+        this.#last = runtime;
+        return runtime;
+    }
+}

package/dist/host/create-host-runtimes.d.ts

@@ -1,2 +1,3 @@
 import type { AgentRuntime } from "../core/types";
-export declare function createHostAgentRuntimes(): AgentRuntime[];
+import type { ControllerConnectionPool } from "./controller-connection";
+export declare function createHostAgentRuntimes(connections: ControllerConnectionPool): AgentRuntime[];

package/dist/host/create-host-runtimes.js

@@ -1,14 +1,12 @@
 import { hasNativeDesktopCapability } from "@lapis-notes/api/desktop-native";
-import { AcpAgentRuntime } from "../runtimes/acp/acp-runtime";
-import { DesktopAcpRuntimeBackend } from "../runtimes/acp/desktop-acp-backend";
-import { CodexNativeRuntime } from "../runtimes/codex/codex-runtime";
-import { createAgentProcessHost } from "./desktop-process-host";
+import { ControllerAgentRuntime } from "./controller-runtime";
 import { hostLiveRuntimesEnabled } from "./host-runtime-availability";
-export function createHostAgentRuntimes() {
+export function createHostAgentRuntimes(connections) {
     if (!hostLiveRuntimesEnabled(hasNativeDesktopCapability))
         return [];
     return [
-        new AcpAgentRuntime(new DesktopAcpRuntimeBackend()),
-        new CodexNativeRuntime(createAgentProcessHost()),
+        new ControllerAgentRuntime("acp", connections),
+        new ControllerAgentRuntime("codex-native", connections),
+        new ControllerAgentRuntime("opencode-native", connections),
     ];
 }

package/dist/index.d.ts

@@ -65,5 +65,5 @@ export { buildAgentBootstrap, buildSessionBootstrap } from "./bootstrap/build";
 export { createMcpServerContributionRegistry } from "./tools/mcp-server-registry";
 export { APP_TOOL_MCP_SERVER_NAME } from "./tools/mcp-server-registry";
 export { AppToolApprovalBroker, AppToolExecutionError, AppToolHost, } from "./tools/app-tool-host";
-export type { AppToolCall, AppToolExecutionErrorCode, AppToolPolicySettings, CreateAppToolSessionInput, } from "./tools/app-tool-host";
+export type { AppToolCall, AppToolCapture, AppToolExecutionErrorCode, AppToolPolicySettings, CreateAppToolSessionInput, } from "./tools/app-tool-host";
 export type { McpServerContributionRegistry } from "./tools/mcp-server-registry";

package/dist/memory/candidate-extractor.d.ts

@@ -1,25 +1,2 @@
-import type { AppDatabase } from "@lapis-notes/api";
-import type { ConversationSnapshot, TranscriptEntry } from "../conversations/types";
-import type { DurableMemoryKind } from "./types";
-export type CandidateExtractionResult = {
-    examined: number;
-    staged: number;
-    review: number;
-    rejectedSecrets: number;
-};
-export type CandidateExtractionOptions = {
-    entries?: TranscriptEntry[];
-    yieldToApp?: () => Promise<void>;
-};
-export declare function extractDeterministicCandidates(snapshot: ConversationSnapshot, database: AppDatabase, options?: CandidateExtractionOptions): Promise<CandidateExtractionResult>;
-declare function normalizeClaim(text: string): string;
-declare function supersessionKey(text: string, kind: DurableMemoryKind): string | undefined;
-declare function extractTriggers(claim: string): string[];
-export declare function isSecretBearingMemoryText(text: string): boolean;
-export declare const __candidateExtractorInternals: {
-    containsSecret: typeof isSecretBearingMemoryText;
-    extractTriggers: typeof extractTriggers;
-    normalizeClaim: typeof normalizeClaim;
-    supersessionKey: typeof supersessionKey;
-};
-export {};
+export { extractDeterministicCandidates, isSecretBearingMemoryText, __candidateExtractorInternals, } from "@lapismd/ai-controller/memory/lapis";
+export type { CandidateExtractionResult, CandidateExtractionOptions, } from "@lapismd/ai-controller/memory/lapis";

package/dist/memory/candidate-extractor.js

@@ -1,191 +1 @@
-import { deterministicMemoryId, sha256Text, transcriptEntryHash } from "./hashes";
-import { conversationMemoryScope } from "./paths";
-const SECRET_PATTERNS = [
-    /-----BEGIN [A-Z ]*PRIVATE KEY-----/iu,
-    /\b(?:api[_ -]?key|password|passwd|secret|access[_ -]?token)\s*[:=]\s*\S+/iu,
-    /\b(?:sk|ghp|github_pat|xox[baprs])[-_][A-Za-z0-9_-]{16,}\b/u,
-];
-const EXPLICIT_CUE = /\b(?:remember(?:\s+that)?|i\s+prefer|we\s+decided|always\s+for\s+this\s+project)\b/iu;
-const STABLE_CUE = /\b(?:prefer|uses?|must|should|decided|convention|workflow|constraint)\b/iu;
-const STOP_WORDS = new Set([
-    "a",
-    "an",
-    "and",
-    "are",
-    "as",
-    "at",
-    "be",
-    "for",
-    "i",
-    "in",
-    "is",
-    "it",
-    "of",
-    "on",
-    "or",
-    "that",
-    "the",
-    "this",
-    "to",
-    "use",
-    "uses",
-    "we",
-    "with",
-]);
-export async function extractDeterministicCandidates(snapshot, database, options = {}) {
-    let examined = 0;
-    let staged = 0;
-    let review = 0;
-    let rejectedSecrets = 0;
-    const entries = options.entries ?? snapshot.transcript;
-    for (let index = 0; index < entries.length; index += 1) {
-        const entry = entries[index];
-        if (index > 0 && index % 200 === 0) {
-            await options.yieldToApp?.();
-        }
-        if (entry.type !== "message")
-            continue;
-        const originClass = entry.role === "user" ? "owner" : "agent";
-        if (!STABLE_CUE.test(entry.text) && !EXPLICIT_CUE.test(entry.text))
-            continue;
-        examined += 1;
-        if (isSecretBearingMemoryText(entry.text)) {
-            rejectedSecrets += 1;
-            continue;
-        }
-        const explicit = originClass === "owner" && EXPLICIT_CUE.test(entry.text);
-        const input = await candidateFromEntry(snapshot, entry, originClass, explicit);
-        const existing = (await database.queryMemoryCandidates({
-            scopeKind: input.candidate.scopeKind,
-            scopePath: input.candidate.scopePath,
-            limit: 10_000,
-        })).find((candidate) => candidate.candidate.id === input.candidate.id);
-        const origins = dedupeOrigins([
-            ...(existing?.origins ?? []),
-            ...input.origins,
-        ]);
-        const conversations = new Set(origins.map((origin) => origin.conversationId));
-        const days = new Set(origins.map((origin) => new Date(origin.observedAt).toISOString().slice(0, 10)));
-        const qualifiesRecurring = conversations.size >= 2 && days.size >= 2;
-        const state = originClass === "agent"
-            ? "review"
-            : explicit || qualifiesRecurring
-                ? "staged"
-                : "review";
-        await database.upsertMemoryCandidate({
-            candidate: {
-                ...(existing?.candidate ?? input.candidate),
-                lastSeenAt: Math.max(existing?.candidate.lastSeenAt ?? 0, input.candidate.lastSeenAt),
-                recurrenceCount: origins.length,
-                conversationCount: conversations.size,
-                state: existing?.candidate.state === "promoted"
-                    ? "promoted"
-                    : state,
-            },
-            origins,
-        });
-        if (state === "staged")
-            staged += 1;
-        else
-            review += 1;
-    }
-    return { examined, staged, review, rejectedSecrets };
-}
-async function candidateFromEntry(snapshot, entry, originClass, explicit) {
-    const scope = candidateScope(snapshot.location.scopeDir, entry.text);
-    const normalizedClaim = normalizeClaim(entry.text);
-    const claimHash = await sha256Text(normalizedClaim.toLocaleLowerCase());
-    const scopePath = scope.kind === "project" ? scope.projectDir : "";
-    const kind = candidateKind(entry.text);
-    const id = await deterministicMemoryId("candidate", scope.kind, scopePath, kind, claimHash);
-    const observedAt = Date.parse(entry.createdAt);
-    return {
-        candidate: {
-            id,
-            scopeKind: scope.kind,
-            scopePath,
-            kind,
-            normalizedClaim,
-            claimHash,
-            ...(supersessionKey(entry.text, kind)
-                ? { supersessionKey: supersessionKey(entry.text, kind) }
-                : {}),
-            originClass,
-            importance: explicit ? 4 : 3,
-            triggers: extractTriggers(normalizedClaim),
-            state: originClass === "agent" ? "review" : explicit ? "staged" : "review",
-            firstSeenAt: observedAt,
-            lastSeenAt: observedAt,
-            recurrenceCount: 1,
-            conversationCount: 1,
-        },
-        origins: [
-            {
-                candidateId: id,
-                conversationId: snapshot.location.conversationId,
-                entryId: entry.id,
-                entryHash: await transcriptEntryHash(entry),
-                observedAt,
-            },
-        ],
-    };
-}
-function candidateScope(scopeDir, text) {
-    if (/\b(?:this|the)\s+project\b/iu.test(text) && scopeDir) {
-        return conversationMemoryScope(scopeDir);
-    }
-    if (/\b(?:i\s+prefer|my\s+preference)\b/iu.test(text)) {
-        return { kind: "user" };
-    }
-    return scopeDir
-        ? conversationMemoryScope(scopeDir)
-        : { kind: "workspace" };
-}
-function normalizeClaim(text) {
-    return text
-        .replace(/^\s*(?:please\s+)?remember(?:\s+that)?\s+/iu, "")
-        .replace(/^\s*i\s+prefer\s+/iu, "Prefer ")
-        .replace(/^\s*we\s+decided\s+(?:that\s+|to\s+)?/iu, "")
-        .replace(/^\s*always\s+for\s+this\s+project[,;:]?\s*/iu, "")
-        .replace(/\s+/gu, " ")
-        .trim()
-        .replace(/[.!?]+$/u, "");
-}
-function candidateKind(text) {
-    if (/\bprefer(?:ence)?\b/iu.test(text))
-        return "preference";
-    if (/\bdecided\b/iu.test(text))
-        return "decision";
-    if (/\b(?:must|never|always|constraint)\b/iu.test(text))
-        return "constraint";
-    if (/\b(?:workflow|procedure|steps?|run|execute)\b/iu.test(text)) {
-        return "procedure";
-    }
-    return "fact";
-}
-function supersessionKey(text, kind) {
-    const normalized = normalizeClaim(text).toLocaleLowerCase();
-    const subject = /^(.{2,80}?)\s+(?:is|are|uses?|must|should)\b/u.exec(normalized)?.[1];
-    if (!subject)
-        return undefined;
-    return `${kind}:${subject.replace(/[^\p{L}\p{N}]+/gu, "-").replace(/^-|-$/gu, "")}`;
-}
-function extractTriggers(claim) {
-    const tokens = claim.toLocaleLowerCase().match(/[\p{L}\p{N}_-]+/gu) ?? [];
-    return [...new Set(tokens.filter((token) => token.length > 2 && !STOP_WORDS.has(token)))].slice(0, 8);
-}
-export function isSecretBearingMemoryText(text) {
-    return SECRET_PATTERNS.some((pattern) => pattern.test(text));
-}
-function dedupeOrigins(origins) {
-    return [...new Map(origins.map((origin) => [
-            `${origin.conversationId}\u0000${origin.entryId}`,
-            origin,
-        ])).values()].sort((left, right) => `${left.conversationId}\u0000${left.entryId}`.localeCompare(`${right.conversationId}\u0000${right.entryId}`));
-}
-export const __candidateExtractorInternals = {
-    containsSecret: isSecretBearingMemoryText,
-    extractTriggers,
-    normalizeClaim,
-    supersessionKey,
-};
+export { extractDeterministicCandidates, isSecretBearingMemoryText, __candidateExtractorInternals, } from "@lapismd/ai-controller/memory/lapis";

package/dist/memory/hashes.d.ts

@@ -1,5 +1 @@
-import type { TranscriptEntry } from "../conversations/types";
-export declare function sha256Text(value: string): Promise<string>;
-export declare function canonicalJson(value: unknown): string;
-export declare function transcriptEntryHash(entry: TranscriptEntry): Promise<string>;
-export declare function deterministicMemoryId(namespace: string, ...parts: string[]): Promise<string>;
+export { sha256Text, canonicalJson, transcriptEntryHash, deterministicMemoryId, } from "@lapismd/ai-controller/memory/lapis";

package/dist/memory/hashes.js

@@ -1,37 +1 @@
-function canonicalize(value) {
-    if (value === null || typeof value === "boolean" || typeof value === "string") {
-        return JSON.stringify(value);
-    }
-    if (typeof value === "number") {
-        if (!Number.isFinite(value))
-            throw new Error("Cannot hash a non-finite number");
-        return JSON.stringify(value);
-    }
-    if (Array.isArray(value)) {
-        return `[${value.map(canonicalize).join(",")}]`;
-    }
-    if (typeof value === "object") {
-        const record = value;
-        return `{${Object.keys(record)
-            .filter((key) => record[key] !== undefined)
-            .sort()
-            .map((key) => `${JSON.stringify(key)}:${canonicalize(record[key])}`)
-            .join(",")}}`;
-    }
-    throw new Error(`Cannot hash ${typeof value}`);
-}
-export async function sha256Text(value) {
-    const digest = await globalThis.crypto.subtle.digest("SHA-256", new TextEncoder().encode(value));
-    return [...new Uint8Array(digest)]
-        .map((byte) => byte.toString(16).padStart(2, "0"))
-        .join("");
-}
-export function canonicalJson(value) {
-    return canonicalize(value);
-}
-export function transcriptEntryHash(entry) {
-    return sha256Text(canonicalJson(entry));
-}
-export async function deterministicMemoryId(namespace, ...parts) {
-    return `${namespace}-${(await sha256Text(parts.join("\u0000"))).slice(0, 32)}`;
-}
+export { sha256Text, canonicalJson, transcriptEntryHash, deterministicMemoryId, } from "@lapismd/ai-controller/memory/lapis";

package/dist/memory/memory-record-store.d.ts

@@ -1,28 +1,8 @@
 import { type Vault } from "@lapis-notes/api/vault";
-import { canonicalJson } from "./hashes";
+import { type MemoryRecordStore, type StoredMemoryRecord, type MemoryRecordWriteOptions, type DurableMemoryRecord, type MemoryScope } from "@lapismd/ai-controller/memory/lapis";
 import type { ConversationLocation } from "../conversations/types";
-import type { DurableMemoryRecord, MemoryScope } from "./types";
-export type StoredMemoryRecord = {
-    record: DurableMemoryRecord;
-    path: string;
-    hash: string;
-    content: string;
-};
-export type MemoryRecordWriteOptions = {
-    expectedCurrentHash?: string;
-};
-export interface MemoryRecordStore {
-    list(scope?: MemoryScope): Promise<StoredMemoryRecord[]>;
-    find(id: string): Promise<StoredMemoryRecord[]>;
-    write(record: DurableMemoryRecord, options?: MemoryRecordWriteOptions): Promise<StoredMemoryRecord>;
-    listHistory(id: string, scope: MemoryScope): Promise<DurableMemoryRecord[]>;
-    writeReview(scope: MemoryScope, jobId: string, markdown: string): Promise<string>;
-    listExcludedConversationIds(): Promise<Set<string>>;
-    writeConversationExclusion(location: ConversationLocation): Promise<string>;
-}
-export declare class MemoryRecordConflictError extends Error {
-    constructor(message: string);
-}
+export { InMemoryMemoryRecordStore, MemoryRecordConflictError, serializeMemoryRecord, validateMemoryRecord, recordPath, recordDirectory, memoryRoot, __memoryRecordStoreInternals, } from "@lapismd/ai-controller/memory/lapis";
+export type { MemoryRecordStore, StoredMemoryRecord, MemoryRecordWriteOptions, } from "@lapismd/ai-controller/memory/lapis";
 export declare class VaultMemoryRecordStore implements MemoryRecordStore {
     private readonly vault;
     constructor(vault: Vault);
@@ -35,28 +15,3 @@ export declare class VaultMemoryRecordStore implements MemoryRecordStore {
     writeConversationExclusion(location: ConversationLocation): Promise<string>;
     private writeImmutablePreimage;
 }
-export declare class InMemoryMemoryRecordStore implements MemoryRecordStore {
-    #private;
-    list(scope?: MemoryScope): Promise<StoredMemoryRecord[]>;
-    find(id: string): Promise<StoredMemoryRecord[]>;
-    write(record: DurableMemoryRecord, options?: MemoryRecordWriteOptions): Promise<StoredMemoryRecord>;
-    listHistory(id: string, scope: MemoryScope): Promise<DurableMemoryRecord[]>;
-    writeReview(scope: MemoryScope, jobId: string, markdown: string): Promise<string>;
-    listExcludedConversationIds(): Promise<Set<string>>;
-    writeConversationExclusion(location: ConversationLocation): Promise<string>;
-}
-export declare function memoryRoot(scope: MemoryScope): string;
-export declare function recordDirectory(scope: MemoryScope): string;
-export declare function recordPath(scope: MemoryScope, id: string): string;
-declare function revisionDirectory(scope: MemoryScope, id: string): string;
-export declare function serializeMemoryRecord(record: DurableMemoryRecord): string;
-declare function parseStoredRecord(path: string, content: string): Promise<StoredMemoryRecord>;
-export declare function validateMemoryRecord(value: unknown): DurableMemoryRecord;
-declare function scopeKey(scope: MemoryScope): string;
-export declare const __memoryRecordStoreInternals: {
-    parseStoredRecord: typeof parseStoredRecord;
-    revisionDirectory: typeof revisionDirectory;
-    scopeKey: typeof scopeKey;
-    canonicalJson: typeof canonicalJson;
-};
-export {};