@botbotgo/agent-harness 0.0.1

package/dist/runtime/support/llamaindex.js

@@ -0,0 +1,108 @@
+import path from "node:path";
+import { mkdir } from "node:fs/promises";
+import { Document, NodeRelationship, SimpleVectorStore, VectorStoreQueryMode } from "llamaindex";
+import { OllamaEmbedding } from "@llamaindex/ollama";
+function resolveLlamaIndexOllamaInit(init) {
+    const config = typeof init.config === "object" && init.config
+        ? { ...init.config }
+        : {};
+    if (typeof init.baseUrl === "string" && !("host" in config)) {
+        config.host = init.baseUrl;
+    }
+    const options = typeof init.options === "object" && init.options
+        ? { ...init.options }
+        : undefined;
+    return {
+        model: String(init.model ?? ""),
+        config,
+        ...(options ? { options } : {}),
+    };
+}
+function resolveFilePath(rawUrl, workspaceRoot) {
+    const normalized = rawUrl.startsWith("file:") ? rawUrl.slice("file:".length) : rawUrl;
+    return path.isAbsolute(normalized) ? normalized : path.resolve(workspaceRoot, normalized);
+}
+export function createLlamaIndexEmbeddingModel(embeddingModel) {
+    if (embeddingModel.provider !== "llamaindex-ollama") {
+        throw new Error(`Embedding model provider ${embeddingModel.provider} is not supported by the built-in LlamaIndex runtime.`);
+    }
+    const runtime = new OllamaEmbedding({
+        ...resolveLlamaIndexOllamaInit({
+            ...embeddingModel.init,
+            model: embeddingModel.model,
+        }),
+    });
+    return {
+        async embedDocuments(texts) {
+            return Promise.all(texts.map((text) => runtime.getTextEmbedding(text)));
+        },
+        async embedQuery(text) {
+            return runtime.getTextEmbedding(text);
+        },
+    };
+}
+export async function createLlamaIndexVectorStore(workspaceRoot, vectorStore, embeddings) {
+    const persistPath = resolveFilePath(vectorStore.url ?? ".agent/vector_store.json", workspaceRoot);
+    await mkdir(path.dirname(persistPath), { recursive: true });
+    const emptyStore = () => SimpleVectorStore.fromDict({
+        embeddingDict: {},
+        textIdToRefDocId: {},
+        metadataDict: {},
+    }, embeddings);
+    let store = await SimpleVectorStore.fromPersistPath(persistPath, embeddings);
+    return {
+        kind: vectorStore.kind,
+        embeddingModelRef: vectorStore.embeddingModelRef,
+        async addDocuments(documents) {
+            const ids = documents.map((_, index) => `${Date.now()}-${index}-${Math.random().toString(36).slice(2, 10)}`);
+            const vectors = documents.length > 0 ? await embeddings.embedDocuments(documents.map((document) => document.pageContent)) : [];
+            const nodes = documents.map((document, index) => new Document({
+                id_: ids[index],
+                text: document.pageContent,
+                embedding: vectors[index] ?? [],
+                metadata: {
+                    ...(document.metadata ?? {}),
+                    __pageContent: document.pageContent,
+                },
+                relationships: {
+                    [NodeRelationship.SOURCE]: {
+                        nodeId: ids[index] ?? "",
+                        metadata: document.metadata ?? {},
+                    },
+                },
+            }));
+            const created = await store.add(nodes);
+            await store.persist(persistPath);
+            return created;
+        },
+        async similaritySearch(query, limit) {
+            const queryEmbedding = await embeddings.embedQuery(query);
+            const result = await store.query({
+                queryEmbedding,
+                similarityTopK: limit,
+                mode: VectorStoreQueryMode.DEFAULT,
+            });
+            return result.ids.map((id, index) => {
+                const metadata = (store.toDict().metadataDict[id] ?? {});
+                const pageContent = typeof metadata.__pageContent === "string" ? metadata.__pageContent : "";
+                const { __pageContent: _, ...rest } = metadata;
+                return {
+                    pageContent,
+                    metadata: rest,
+                    score: result.similarities[index],
+                };
+            });
+        },
+        async delete(params) {
+            if (params.deleteAll) {
+                store = emptyStore();
+                await store.persist(persistPath);
+                return;
+            }
+            for (const id of params.ids ?? []) {
+                await store.delete(id);
+            }
+            await store.persist(persistPath);
+        },
+    };
+}

package/dist/runtime/support/runtime-factories.d.ts

@@ -0,0 +1,3 @@
+import { type StoreLike } from "../store.js";
+export declare function createStoreForConfig(storeConfig: Record<string, unknown>, runRoot: string): StoreLike;
+export declare function createCheckpointerForConfig(checkpointerConfig: Record<string, unknown>, runRoot: string): unknown;

package/dist/runtime/support/runtime-factories.js

@@ -0,0 +1,39 @@
+import path from "node:path";
+import { MemorySaver } from "@langchain/langgraph";
+import { SqliteSaver } from "@langchain/langgraph-checkpoint-sqlite";
+import { FileCheckpointSaver } from "../file-checkpoint-saver.js";
+import { createInMemoryStore, FileBackedStore } from "../store.js";
+export function createStoreForConfig(storeConfig, runRoot) {
+    const kind = typeof storeConfig.kind === "string" ? storeConfig.kind : "FileStore";
+    switch (kind) {
+        case "FileStore": {
+            const configuredPath = typeof storeConfig.path === "string" ? storeConfig.path : "store.json";
+            return new FileBackedStore(path.isAbsolute(configuredPath) ? configuredPath : path.join(runRoot, configuredPath));
+        }
+        case "InMemoryStore":
+            return createInMemoryStore();
+        case "RedisStore":
+            throw new Error("Store kind RedisStore is not implemented in this runtime yet");
+        case "PostgresStore":
+            throw new Error("Store kind PostgresStore is not implemented in this runtime yet");
+        default:
+            throw new Error(`Unsupported store kind ${String(kind)}`);
+    }
+}
+export function createCheckpointerForConfig(checkpointerConfig, runRoot) {
+    const kind = typeof checkpointerConfig.kind === "string" ? checkpointerConfig.kind : "FileCheckpointer";
+    switch (kind) {
+        case "MemorySaver":
+            return new MemorySaver();
+        case "SqliteSaver": {
+            const configuredPath = typeof checkpointerConfig.path === "string" ? String(checkpointerConfig.path) : "checkpoints.sqlite";
+            return SqliteSaver.fromConnString(path.isAbsolute(configuredPath) ? configuredPath : path.join(runRoot, configuredPath));
+        }
+        case "FileCheckpointer": {
+            const configuredPath = typeof checkpointerConfig.path === "string" ? String(checkpointerConfig.path) : "checkpoints.json";
+            return new FileCheckpointSaver(path.isAbsolute(configuredPath) ? configuredPath : path.join(runRoot, configuredPath));
+        }
+        default:
+            throw new Error(`Unsupported checkpointer kind ${String(kind)}`);
+    }
+}

package/dist/runtime/support/skill-metadata.d.ts

@@ -0,0 +1 @@
+export declare function readSkillName(skillPath: string): string;

package/dist/runtime/support/skill-metadata.js

@@ -0,0 +1,34 @@
+import { readFileSync } from "node:fs";
+import path from "node:path";
+const skillNameCache = new Map();
+function parseFrontmatterName(document) {
+    const match = document.match(/^---\s*\n([\s\S]*?)\n---\s*(?:\n|$)/);
+    if (!match) {
+        return undefined;
+    }
+    const nameLine = match[1]
+        .split("\n")
+        .map((line) => line.trim())
+        .find((line) => line.startsWith("name:"));
+    if (!nameLine) {
+        return undefined;
+    }
+    const value = nameLine.slice("name:".length).trim().replace(/^["']|["']$/g, "");
+    return value || undefined;
+}
+export function readSkillName(skillPath) {
+    const cached = skillNameCache.get(skillPath);
+    if (cached) {
+        return cached;
+    }
+    let resolvedName = path.basename(skillPath);
+    try {
+        const document = readFileSync(path.join(skillPath, "SKILL.md"), "utf8");
+        resolvedName = parseFrontmatterName(document) ?? resolvedName;
+    }
+    catch {
+        // Fall back to the directory name when the skill doc cannot be read.
+    }
+    skillNameCache.set(skillPath, resolvedName);
+    return resolvedName;
+}

package/dist/runtime/support/vector-stores.d.ts

@@ -0,0 +1,7 @@
+import type { CompiledVectorStore, RuntimeEmbeddingModelResolver, RuntimeVectorStoreResolver, WorkspaceBundle } from "../../contracts/types.js";
+import { type VectorStoreRuntimeLike } from "./llamaindex.js";
+export declare function resolveCompiledVectorStoreRef(workspace: WorkspaceBundle, vectorStoreRef?: string): CompiledVectorStore;
+export declare function resolveCompiledVectorStore(workspace: WorkspaceBundle, vectorStore: CompiledVectorStore, options?: {
+    embeddingModelResolver?: RuntimeEmbeddingModelResolver;
+    vectorStoreResolver?: RuntimeVectorStoreResolver;
+}): Promise<VectorStoreRuntimeLike>;

package/dist/runtime/support/vector-stores.js

@@ -0,0 +1,130 @@
+import path from "node:path";
+import { mkdir } from "node:fs/promises";
+import { Document } from "@langchain/core/documents";
+import { createClient } from "@libsql/client";
+import { LibSQLVectorStore } from "@langchain/community/vectorstores/libsql";
+import { compileVectorStore } from "../../workspace/resource-compilers.js";
+import { resolveRefId } from "../../workspace/support/workspace-ref-utils.js";
+import { resolveCompiledEmbeddingModel, resolveCompiledEmbeddingModelRef } from "./embedding-models.js";
+import { createLlamaIndexVectorStore } from "./llamaindex.js";
+function resolveFileUrl(rawUrl, workspaceRoot) {
+    if (!rawUrl.startsWith("file:")) {
+        return rawUrl;
+    }
+    const filePath = rawUrl.slice("file:".length);
+    if (!filePath) {
+        return rawUrl;
+    }
+    if (path.isAbsolute(filePath)) {
+        return `file:${filePath}`;
+    }
+    return `file:${path.resolve(workspaceRoot, filePath)}`;
+}
+async function ensureFileUrlDirectory(rawUrl, workspaceRoot) {
+    const resolvedUrl = resolveFileUrl(rawUrl, workspaceRoot);
+    if (!resolvedUrl.startsWith("file:")) {
+        return resolvedUrl;
+    }
+    const filePath = resolvedUrl.slice("file:".length);
+    await mkdir(path.dirname(filePath), { recursive: true });
+    return resolvedUrl;
+}
+function assertIdentifier(value, label) {
+    if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(value)) {
+        throw new Error(`Invalid ${label} ${value}. Use only letters, numbers, and underscores.`);
+    }
+    return value;
+}
+async function ensureLibSqlSchema(db, table, column, dimensions) {
+    const safeTable = assertIdentifier(table, "table name");
+    const safeColumn = assertIdentifier(column, "column name");
+    const safeIndex = assertIdentifier(`idx_${safeTable}_${safeColumn}`, "index name");
+    await db.execute(`
+    CREATE TABLE IF NOT EXISTS ${safeTable} (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      content TEXT NOT NULL,
+      metadata TEXT NOT NULL,
+      ${safeColumn} F32_BLOB(${dimensions}) NOT NULL
+    )
+  `);
+    await db.execute(`
+    CREATE INDEX IF NOT EXISTS ${safeIndex}
+    ON ${safeTable}(libsql_vector_idx(${safeColumn}))
+  `);
+}
+export function resolveCompiledVectorStoreRef(workspace, vectorStoreRef) {
+    const resolvedId = vectorStoreRef ? resolveRefId(vectorStoreRef) : "default";
+    const vectorStore = workspace.vectorStores.get(resolvedId);
+    if (vectorStore) {
+        return compileVectorStore(vectorStore);
+    }
+    if (!vectorStoreRef && workspace.vectorStores.size === 1) {
+        const soleStore = workspace.vectorStores.values().next().value;
+        if (soleStore) {
+            return compileVectorStore(soleStore);
+        }
+    }
+    throw new Error(`Missing vector store ${vectorStoreRef ?? "vector-store/default"}`);
+}
+export async function resolveCompiledVectorStore(workspace, vectorStore, options = {}) {
+    if (options.vectorStoreResolver) {
+        return options.vectorStoreResolver(vectorStore.id);
+    }
+    if (vectorStore.kind === "LlamaIndexSimpleVectorStore") {
+        const embeddingModel = resolveCompiledEmbeddingModelRef(workspace, vectorStore.embeddingModelRef);
+        const embeddings = await resolveCompiledEmbeddingModel(embeddingModel, options.embeddingModelResolver);
+        return createLlamaIndexVectorStore(workspace.workspaceRoot, vectorStore, embeddings);
+    }
+    if (vectorStore.kind !== "LibSQLVectorStore") {
+        throw new Error(`Vector store kind ${vectorStore.kind} is not supported by the built-in runtime.`);
+    }
+    const embeddingModel = resolveCompiledEmbeddingModelRef(workspace, vectorStore.embeddingModelRef);
+    const embeddings = await resolveCompiledEmbeddingModel(embeddingModel, options.embeddingModelResolver);
+    const db = createClient({
+        url: await ensureFileUrlDirectory(vectorStore.url ?? "", workspace.workspaceRoot),
+        ...(vectorStore.authToken ? { authToken: vectorStore.authToken } : {}),
+    });
+    const table = vectorStore.table ?? "vectors";
+    const column = vectorStore.column ?? "embedding";
+    const ensureSchemaForTexts = async (texts) => {
+        const seedText = texts.find((text) => text.trim().length > 0) ?? "seed";
+        const sample = await embeddings.embedQuery(seedText);
+        await ensureLibSqlSchema(db, table, column, sample.length);
+    };
+    return {
+        kind: vectorStore.kind,
+        embeddingModelRef: vectorStore.embeddingModelRef,
+        addDocuments: async (documents) => {
+            await ensureSchemaForTexts(documents.map((document) => document.pageContent));
+            const store = new LibSQLVectorStore(embeddings, {
+                db,
+                table,
+                column,
+            });
+            return store.addDocuments(documents.map((document) => new Document(document)));
+        },
+        similaritySearch: async (query, limit) => {
+            await ensureSchemaForTexts([query]);
+            const store = new LibSQLVectorStore(embeddings, {
+                db,
+                table,
+                column,
+            });
+            const rows = await store.similaritySearchWithScore(query, limit);
+            return rows.map(([document, score]) => ({
+                pageContent: document.pageContent,
+                metadata: document.metadata,
+                score: typeof score === "number" ? 1 - score : score,
+            }));
+        },
+        delete: async (params) => {
+            await ensureSchemaForTexts(["seed"]);
+            const store = new LibSQLVectorStore(embeddings, {
+                db,
+                table,
+                column,
+            });
+            await store.delete(params);
+        },
+    };
+}

package/dist/runtime/thread-memory-sync.d.ts

@@ -0,0 +1,14 @@
+import type { HarnessEvent } from "../contracts/types.js";
+import type { FilePersistence } from "../persistence/file-store.js";
+export declare class ThreadMemorySync {
+    private readonly persistence;
+    private readonly store?;
+    private readonly pending;
+    constructor(persistence: FilePersistence, store?: {
+        put: (namespace: string[], key: string, value: Record<string, any>) => Promise<void>;
+    } | undefined);
+    handleEvent(event: HarnessEvent): Promise<void>;
+    private syncThread;
+    close(): Promise<void>;
+}
+export { ThreadMemorySync as MemoryWorker };

package/dist/runtime/thread-memory-sync.js

@@ -0,0 +1,88 @@
+function excerpt(message) {
+    if (!message?.content) {
+        return "(none)";
+    }
+    const normalized = message.content.replace(/\s+/g, " ").trim();
+    return normalized.length > 240 ? `${normalized.slice(0, 237)}...` : normalized;
+}
+function renderStatusMarkdown(session, messages) {
+    const userMessages = messages.filter((message) => message.role === "user");
+    const assistantMessages = messages.filter((message) => message.role === "assistant");
+    return [
+        "# Thread Status",
+        "",
+        `- thread_id: ${session.threadId}`,
+        `- latest_run_id: ${session.latestRunId}`,
+        `- agent_id: ${session.agentId}`,
+        `- status: ${session.status}`,
+        `- updated_at: ${session.updatedAt}`,
+        "",
+        "## Recent User Message",
+        excerpt(userMessages.at(-1)),
+        "",
+        "## Recent Assistant Message",
+        excerpt(assistantMessages.at(-1)),
+        "",
+    ].join("\n");
+}
+function renderOpenApprovalsMarkdown(approvals) {
+    if (approvals.length === 0) {
+        return ["# Open Approvals", "", "(none)", ""].join("\n");
+    }
+    const lines = ["# Open Approvals", ""];
+    for (const approval of approvals) {
+        lines.push(`## ${approval.approvalId}`);
+        lines.push(`- pending_action_id: ${approval.pendingActionId}`);
+        lines.push(`- tool: ${approval.toolName}`);
+        lines.push(`- run_id: ${approval.runId}`);
+        lines.push(`- requested_at: ${approval.requestedAt}`);
+        lines.push(`- allowed: ${approval.allowedDecisions.join(", ")}`);
+        lines.push("");
+    }
+    return lines.join("\n");
+}
+export class ThreadMemorySync {
+    persistence;
+    store;
+    pending = new Set();
+    constructor(persistence, store) {
+        this.persistence = persistence;
+        this.store = store;
+    }
+    async handleEvent(event) {
+        if (event.eventType !== "run.state.changed" && event.eventType !== "approval.resolved" && event.eventType !== "approval.requested") {
+            return;
+        }
+        const task = this.syncThread(event.threadId)
+            .catch(() => {
+            // Fail open: background memory digestion must not break the hot path.
+        })
+            .finally(() => {
+            this.pending.delete(task);
+        });
+        this.pending.add(task);
+        await task;
+    }
+    async syncThread(threadId) {
+        const session = await this.persistence.getSession(threadId);
+        if (!session) {
+            return;
+        }
+        const [messages, approvals] = await Promise.all([
+            this.persistence.listThreadMessages(threadId, 24),
+            this.persistence.listApprovals(),
+        ]);
+        const pendingApprovals = approvals.filter((approval) => approval.threadId === threadId && approval.status === "pending");
+        if (!this.store) {
+            return;
+        }
+        await Promise.all([
+            this.store.put(["memories", "threads", threadId], "status.md", { content: `${renderStatusMarkdown(session, messages)}\n` }),
+            this.store.put(["memories", "threads", threadId], "open-approvals.md", { content: `${renderOpenApprovalsMarkdown(pendingApprovals)}\n` }),
+        ]);
+    }
+    async close() {
+        await Promise.allSettled(Array.from(this.pending));
+    }
+}
+export { ThreadMemorySync as MemoryWorker };

package/dist/runtime/tool-hitl.d.ts

@@ -0,0 +1,5 @@
+import type { CompiledTool } from "../contracts/types.js";
+type InterruptFn = <I = unknown, R = unknown>(value: I) => R;
+export declare function wrapToolForHumanInTheLoop<T>(resolvedTool: T, compiledTool: CompiledTool, interruptFn?: InterruptFn): T;
+export declare function wrapToolForExecution<T>(resolvedTool: T, compiledTool: CompiledTool, interruptFn?: InterruptFn): T;
+export {};

package/dist/runtime/tool-hitl.js

@@ -0,0 +1,108 @@
+import { interrupt } from "@langchain/langgraph";
+const DEDUPED_REMOTE_TOOL_NAMES = new Set(["builtin.fetch_url", "builtin.web_search"]);
+function toInputPreview(input) {
+    if (typeof input === "object" && input && !Array.isArray(input)) {
+        return input;
+    }
+    return { input };
+}
+function resolveApprovedInput(originalInput, resumeValue) {
+    if (resumeValue === "reject") {
+        return Symbol.for("agent-harness.hitl.reject");
+    }
+    if (typeof resumeValue === "object" && resumeValue && "decision" in resumeValue) {
+        const typed = resumeValue;
+        if (typed.decision === "reject") {
+            return Symbol.for("agent-harness.hitl.reject");
+        }
+        if (typed.decision === "edit" && typed.editedInput !== undefined) {
+            return typed.editedInput;
+        }
+    }
+    return originalInput;
+}
+export function wrapToolForHumanInTheLoop(resolvedTool, compiledTool, interruptFn = interrupt) {
+    if (!compiledTool.hitl?.enabled || typeof resolvedTool !== "object" || resolvedTool === null) {
+        return resolvedTool;
+    }
+    const target = resolvedTool;
+    const runWithApproval = async (input, config, invokeOriginal) => {
+        const resumed = interruptFn({
+            toolName: compiledTool.name,
+            toolId: compiledTool.id,
+            allowedDecisions: compiledTool.hitl?.allow ?? ["approve", "edit", "reject"],
+            inputPreview: toInputPreview(input),
+        });
+        const approvedInput = resolveApprovedInput(input, resumed);
+        if (approvedInput === Symbol.for("agent-harness.hitl.reject")) {
+            return "Tool execution rejected by human reviewer.";
+        }
+        return invokeOriginal(approvedInput, config);
+    };
+    return new Proxy(target, {
+        get(obj, prop, receiver) {
+            const value = Reflect.get(obj, prop, receiver);
+            if (prop === "invoke" && typeof value === "function") {
+                return (input, config) => runWithApproval(input, config, (approvedInput, approvedConfig) => obj.invoke(approvedInput, approvedConfig));
+            }
+            if (prop === "call" && typeof value === "function") {
+                return (input, config) => runWithApproval(input, config, (approvedInput, approvedConfig) => obj.call(approvedInput, approvedConfig));
+            }
+            if (prop === "func" && typeof value === "function") {
+                return (input, config) => runWithApproval(input, config, (approvedInput, approvedConfig) => obj.func(approvedInput, approvedConfig));
+            }
+            return value;
+        },
+    });
+}
+function stableStringify(value) {
+    if (value === null || typeof value !== "object") {
+        return JSON.stringify(value);
+    }
+    if (Array.isArray(value)) {
+        return `[${value.map((item) => stableStringify(item)).join(",")}]`;
+    }
+    const entries = Object.entries(value).sort(([left], [right]) => left.localeCompare(right));
+    return `{${entries.map(([key, nested]) => `${JSON.stringify(key)}:${stableStringify(nested)}`).join(",")}}`;
+}
+function createDedupedToolKey(toolName, input) {
+    return `${toolName}:${stableStringify(input)}`;
+}
+function wrapToolWithDedupe(resolvedTool, compiledTool) {
+    if (!DEDUPED_REMOTE_TOOL_NAMES.has(compiledTool.name) || typeof resolvedTool !== "object" || resolvedTool === null) {
+        return resolvedTool;
+    }
+    const target = resolvedTool;
+    const cache = new Map();
+    const dedupeCall = (input, config, invokeOriginal) => {
+        const cacheKey = createDedupedToolKey(compiledTool.name, input);
+        const cached = cache.get(cacheKey);
+        if (cached) {
+            return cached;
+        }
+        const pending = Promise.resolve(invokeOriginal(input, config)).catch((error) => {
+            cache.delete(cacheKey);
+            throw error;
+        });
+        cache.set(cacheKey, pending);
+        return pending;
+    };
+    return new Proxy(target, {
+        get(obj, prop, receiver) {
+            const value = Reflect.get(obj, prop, receiver);
+            if (prop === "invoke" && typeof value === "function") {
+                return (input, config) => dedupeCall(input, config, (approvedInput, approvedConfig) => obj.invoke(approvedInput, approvedConfig));
+            }
+            if (prop === "call" && typeof value === "function") {
+                return (input, config) => dedupeCall(input, config, (approvedInput, approvedConfig) => obj.call(approvedInput, approvedConfig));
+            }
+            if (prop === "func" && typeof value === "function") {
+                return (input, config) => dedupeCall(input, config, (approvedInput, approvedConfig) => obj.func(approvedInput, approvedConfig));
+            }
+            return value;
+        },
+    });
+}
+export function wrapToolForExecution(resolvedTool, compiledTool, interruptFn = interrupt) {
+    return wrapToolWithDedupe(wrapToolForHumanInTheLoop(resolvedTool, compiledTool, interruptFn), compiledTool);
+}

package/dist/utils/fs.d.ts

@@ -0,0 +1,6 @@
+export declare function ensureDir(dirPath: string): Promise<void>;
+export declare function readYamlOrJson(filePath: string): Promise<string>;
+export declare function writeJson(filePath: string, value: unknown): Promise<void>;
+export declare function readJson<T>(filePath: string): Promise<T>;
+export declare function fileExists(filePath: string): Promise<boolean>;
+export declare function listFilesRecursive(root: string, suffix: string): Promise<string[]>;

package/dist/utils/fs.js

@@ -0,0 +1,39 @@
+import { mkdir, readFile, readdir, stat, writeFile } from "node:fs/promises";
+import path from "node:path";
+export async function ensureDir(dirPath) {
+    await mkdir(dirPath, { recursive: true });
+}
+export async function readYamlOrJson(filePath) {
+    return readFile(filePath, "utf8");
+}
+export async function writeJson(filePath, value) {
+    await ensureDir(path.dirname(filePath));
+    await writeFile(filePath, `${JSON.stringify(value, null, 2)}\n`, "utf8");
+}
+export async function readJson(filePath) {
+    return JSON.parse(await readFile(filePath, "utf8"));
+}
+export async function fileExists(filePath) {
+    try {
+        await stat(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function listFilesRecursive(root, suffix) {
+    const items = await readdir(root, { withFileTypes: true });
+    const results = [];
+    for (const item of items) {
+        const fullPath = path.join(root, item.name);
+        if (item.isDirectory()) {
+            results.push(...(await listFilesRecursive(fullPath, suffix)));
+            continue;
+        }
+        if (item.isFile() && fullPath.endsWith(suffix)) {
+            results.push(fullPath);
+        }
+    }
+    return results.sort();
+}

package/dist/utils/id.d.ts

@@ -0,0 +1 @@
+export declare function createPersistentId(now?: Date): string;

package/dist/utils/id.js

@@ -0,0 +1,8 @@
+import { randomUUID } from "node:crypto";
+export function createPersistentId(now = new Date()) {
+    const iso = now.toISOString();
+    const compact = iso.replace(/[-:]/g, "").replace(/\./g, "").replace("Z", "");
+    const [date, time] = compact.split("T");
+    const hhmmss = time.slice(0, 9);
+    return `${date}T${hhmmss}-${randomUUID()}`;
+}

package/dist/vendor/builtins.d.ts

@@ -0,0 +1,23 @@
+import type { RuntimeAdapterOptions, WorkspaceBundle } from "../contracts/types.js";
+type BuiltinToolInfo = {
+    builtinPath: string;
+    backendOperation: string;
+    name: string;
+    description: string;
+    hitl?: {
+        enabled: boolean;
+        allow: Array<"approve" | "edit" | "reject">;
+    };
+};
+export declare function ensureBuiltinSources(sources?: string[], workspaceRoot?: string): Promise<void>;
+export declare const builtinSkillsRoot: () => string;
+export declare const builtinConfigRoot: () => string;
+export declare function listBuiltinTools(sources?: string[], workspaceRoot?: string): Promise<BuiltinToolInfo[]>;
+export declare function listBuiltinToolsForSource(source: string, workspaceRoot?: string): Promise<BuiltinToolInfo[]>;
+export declare function createBuiltinBackendResolver(workspace: WorkspaceBundle): NonNullable<RuntimeAdapterOptions["backendResolver"]>;
+export declare function createBuiltinToolResolver(workspace: WorkspaceBundle, options?: {
+    getStore?: (_binding?: WorkspaceBundle["bindings"] extends Map<any, infer T> ? T : never) => unknown;
+    getEmbeddingModel?: (embeddingModelRef?: string, _binding?: WorkspaceBundle["bindings"] extends Map<any, infer T> ? T : never) => Promise<unknown>;
+    getVectorStore?: (vectorStoreRef?: string, _binding?: WorkspaceBundle["bindings"] extends Map<any, infer T> ? T : never) => Promise<unknown>;
+}): NonNullable<RuntimeAdapterOptions["toolResolver"]>;
+export {};