@botbotgo/agent-harness 0.0.1

package/dist/runtime/parsing/stream-event-parsing.js

@@ -0,0 +1,161 @@
+import { extractReasoningText, extractVisibleOutput, hasToolCalls, readTextContent } from "./output-parsing.js";
+function formatStepValue(value, maxLength = 120) {
+    if (value == null)
+        return "";
+    const normalized = typeof value === "string"
+        ? parseMaybeJson(value)
+        : value;
+    const summarized = summarizeStepValue(normalized);
+    const serialized = typeof summarized === "string"
+        ? summarized
+        : (() => {
+            try {
+                return JSON.stringify(summarized);
+            }
+            catch {
+                return String(summarized);
+            }
+        })();
+    return serialized.length > maxLength ? serialized.slice(0, maxLength) + "…" : serialized;
+}
+function parseMaybeJson(value) {
+    const trimmed = value.trim();
+    if (!trimmed.startsWith("{") && !trimmed.startsWith("[")) {
+        return value;
+    }
+    try {
+        return JSON.parse(trimmed);
+    }
+    catch {
+        return value;
+    }
+}
+function summarizeStepValue(value) {
+    if (typeof value !== "object" || !value) {
+        return value;
+    }
+    const record = value;
+    if (typeof record.url === "string" && typeof record.status === "number") {
+        const warnings = Array.isArray(record.warnings) ? record.warnings.filter((item) => typeof item === "string") : [];
+        return {
+            status: record.status,
+            ok: record.ok,
+            quality: record.quality,
+            source: record.source,
+            warnings,
+        };
+    }
+    return value;
+}
+function humanizeEventName(name) {
+    return name.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/[._-]+/g, " ").replace(/\s+/g, " ").trim().toLowerCase();
+}
+export function extractTerminalStreamOutput(event) {
+    if (typeof event !== "object" || !event)
+        return "";
+    const typed = event;
+    if (typed.event === "on_chat_model_end") {
+        if (hasToolCalls(typed.data?.output))
+            return "";
+        return extractVisibleOutput(typed.data?.output);
+    }
+    if (typed.event === "on_chain_end") {
+        const name = typeof typed.name === "string" ? typed.name : "";
+        if (/middleware|after_model/i.test(name))
+            return "";
+        return extractVisibleOutput(typed.data?.output);
+    }
+    return "";
+}
+export function extractReasoningStreamOutput(event) {
+    if (typeof event !== "object" || !event)
+        return "";
+    const typed = event;
+    return typed.event === "on_chat_model_stream" ? extractReasoningText(typed.data?.chunk) : "";
+}
+export function extractAgentStep(event) {
+    if (typeof event !== "object" || !event)
+        return null;
+    const typed = event;
+    const name = typeof typed.name === "string" ? typed.name : "";
+    if (typed.event === "on_tool_start" || (typed.event === "on_chain_start" && typed.run_type === "tool")) {
+        const inputSummary = formatStepValue(typed.data?.input);
+        return inputSummary ? `tool ${name || "tool"}  ${inputSummary}` : `tool ${name || "tool"}`;
+    }
+    if (typed.event === "on_tool_end" || (typed.event === "on_chain_end" && typed.run_type === "tool")) {
+        const outputSummary = formatStepValue(typed.data?.output, 80);
+        return outputSummary ? `tool ${name || "tool"} done  ${outputSummary}` : `tool ${name || "tool"} done`;
+    }
+    if (typed.event === "on_chat_model_start") {
+        const inputTools = typed.data?.input?.tools;
+        const tools = typed.invocation_params?.tools ?? inputTools ?? [];
+        const toolNames = tools.map((tool) => tool.name ?? tool.function?.name).filter((toolName) => typeof toolName === "string").join(", ");
+        return toolNames ? `calling model  tools: [${toolNames}]` : "calling model…";
+    }
+    if (typed.event === "on_chain_start") {
+        if (/SkillsMiddleware/i.test(name))
+            return "loading skills…";
+        if (/MemoryMiddleware/i.test(name))
+            return "loading memory…";
+        if (/patchToolCallsMiddleware/i.test(name))
+            return "normalizing tool calls…";
+        if (/HumanInTheLoopMiddleware/i.test(name))
+            return "checking approvals…";
+        if (/todoListMiddleware/i.test(name))
+            return "updating plan…";
+        if (/model_request/i.test(name))
+            return "preparing model request…";
+        if (/RunnableLambda/i.test(name) || /^__start__$/.test(name))
+            return null;
+        if (/specialist/i.test(name))
+            return `starting ${humanizeEventName(name)}…`;
+        if (/agent$/i.test(name))
+            return `running ${humanizeEventName(name)}…`;
+    }
+    if (typed.event === "on_chain_end") {
+        if (/specialist/i.test(name))
+            return `${humanizeEventName(name)} done`;
+        if (/agent$/i.test(name) && !/^__start__$/.test(name))
+            return `${humanizeEventName(name)} done`;
+    }
+    return null;
+}
+export function extractToolResult(event) {
+    if (typeof event !== "object" || !event)
+        return null;
+    const typed = event;
+    const isToolEnd = typed.event === "on_tool_end" || (typed.event === "on_chain_end" && typed.run_type === "tool");
+    const toolName = typeof typed.name === "string" ? typed.name : "";
+    if (!isToolEnd || !toolName) {
+        return null;
+    }
+    const rawOutput = typed.data?.output;
+    return {
+        toolName,
+        output: typeof rawOutput === "string" ? parseMaybeJson(rawOutput) : rawOutput,
+    };
+}
+export function extractInterruptPayload(event) {
+    if (typeof event !== "object" || !event)
+        return null;
+    const typed = event;
+    if (typed.event === "on_chain_stream") {
+        const chunk = typed.data?.chunk;
+        if (typeof chunk === "object" && chunk && "__interrupt__" in chunk) {
+            return JSON.stringify(chunk.__interrupt__);
+        }
+    }
+    if (typed.event === "on_chain_end") {
+        const output = typed.data?.output;
+        if (typeof output === "object" && output && "__interrupt__" in output) {
+            return JSON.stringify(output.__interrupt__);
+        }
+    }
+    return null;
+}
+export function normalizeTerminalOutputKey(value) {
+    return value.trim();
+}
+export function readStreamDelta(chunk) {
+    return readTextContent(chunk);
+}

package/dist/runtime/policy-engine.d.ts

@@ -0,0 +1,9 @@
+import type { CompiledAgentBinding } from "../contracts/types.js";
+export type PolicyEngineDecision = {
+    allowed: boolean;
+    reasons: string[];
+};
+export declare class PolicyEngine {
+    evaluate(binding: CompiledAgentBinding): PolicyEngineDecision;
+}
+export { PolicyEngineDecision as GovernanceDecision, PolicyEngine as GovernanceEngine, };

package/dist/runtime/policy-engine.js

@@ -0,0 +1,23 @@
+import { getPolicyEvaluators } from "../extensions.js";
+export class PolicyEngine {
+    evaluate(binding) {
+        const reasons = [];
+        let allowed = true;
+        if (!binding.harnessRuntime.hostFacing) {
+            allowed = false;
+            reasons.push("internal subagents cannot be used as host-facing entrypoints");
+        }
+        for (const evaluator of getPolicyEvaluators()) {
+            const decision = evaluator.evaluate(binding);
+            if (!decision) {
+                continue;
+            }
+            if (!decision.allowed) {
+                allowed = false;
+            }
+            reasons.push(...decision.reasons);
+        }
+        return { allowed, reasons };
+    }
+}
+export { PolicyEngine as GovernanceEngine, };

package/dist/runtime/store.d.ts

@@ -0,0 +1,50 @@
+import { InMemoryStore } from "@langchain/langgraph";
+export type StoreLike = {
+    batch: (...args: any[]) => Promise<readonly unknown[]>;
+    get: (namespace: string[], key: string) => Promise<{
+        value: unknown;
+        key: string;
+        namespace: string[];
+        createdAt: Date;
+        updatedAt: Date;
+    } | null>;
+    search: (namespacePrefix: string[], options?: any) => Promise<Array<{
+        value: unknown;
+        key: string;
+        namespace: string[];
+        createdAt: Date;
+        updatedAt: Date;
+        score?: number;
+    }>>;
+    put: (namespace: string[], key: string, value: Record<string, any>, index?: false | string[]) => Promise<void>;
+    delete: (namespace: string[], key: string) => Promise<void>;
+    listNamespaces: (options?: any) => Promise<string[][]>;
+};
+export declare class FileBackedStore {
+    private readonly filePath;
+    private readonly delegate;
+    private loaded;
+    constructor(filePath: string);
+    private ensureLoaded;
+    private persist;
+    batch(operations: Parameters<InMemoryStore["batch"]>[0]): Promise<readonly unknown[]>;
+    get(namespace: string[], key: string): Promise<{
+        value: unknown;
+        key: string;
+        namespace: string[];
+        createdAt: Date;
+        updatedAt: Date;
+    } | null>;
+    search(namespacePrefix: string[], options?: Parameters<InMemoryStore["search"]>[1]): Promise<Array<{
+        value: unknown;
+        key: string;
+        namespace: string[];
+        createdAt: Date;
+        updatedAt: Date;
+        score?: number;
+    }>>;
+    put(namespace: string[], key: string, value: Record<string, any>, index?: false | string[]): Promise<void>;
+    delete(namespace: string[], key: string): Promise<void>;
+    listNamespaces(options?: Parameters<InMemoryStore["listNamespaces"]>[0]): Promise<string[][]>;
+}
+export declare function createInMemoryStore(): StoreLike;

package/dist/runtime/store.js

@@ -0,0 +1,118 @@
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { InMemoryStore } from "@langchain/langgraph";
+function encodeValue(value) {
+    if (value instanceof Date) {
+        return {
+            __type: "Date",
+            value: value.toISOString(),
+        };
+    }
+    if (value instanceof Uint8Array) {
+        return {
+            __type: "Uint8Array",
+            data: Array.from(value),
+        };
+    }
+    if (value instanceof Map) {
+        return {
+            __type: "Map",
+            entries: Array.from(value.entries()).map(([key, entry]) => [encodeValue(key), encodeValue(entry)]),
+        };
+    }
+    if (Array.isArray(value)) {
+        return value.map((item) => encodeValue(item));
+    }
+    if (typeof value === "object" && value) {
+        return Object.fromEntries(Object.entries(value).map(([key, entry]) => [key, encodeValue(entry)]));
+    }
+    return value;
+}
+function decodeValue(value) {
+    if (Array.isArray(value)) {
+        return value.map((item) => decodeValue(item));
+    }
+    if (typeof value === "object" && value) {
+        const typed = value;
+        if (typed.__type === "Date" && typeof typed.value === "string") {
+            return new Date(typed.value);
+        }
+        if (typed.__type === "Uint8Array" && Array.isArray(typed.data)) {
+            return new Uint8Array(typed.data.map((item) => Number(item)));
+        }
+        if (typed.__type === "Map" && Array.isArray(typed.entries)) {
+            return new Map(typed.entries.map((entry) => {
+                const [key, item] = Array.isArray(entry) ? entry : [undefined, undefined];
+                return [decodeValue(key), decodeValue(item)];
+            }));
+        }
+        return Object.fromEntries(Object.entries(value).map(([key, entry]) => [key, decodeValue(entry)]));
+    }
+    return value;
+}
+export class FileBackedStore {
+    filePath;
+    delegate = new InMemoryStore();
+    loaded = false;
+    constructor(filePath) {
+        this.filePath = filePath;
+    }
+    async ensureLoaded() {
+        if (this.loaded) {
+            return;
+        }
+        try {
+            const raw = await readFile(this.filePath, "utf8");
+            const parsed = JSON.parse(raw);
+            this.delegate.data = decodeValue(parsed.data);
+            this.delegate.vectors = decodeValue(parsed.vectors);
+        }
+        catch {
+            this.delegate.data = new Map();
+            this.delegate.vectors = new Map();
+        }
+        this.loaded = true;
+    }
+    async persist() {
+        await mkdir(path.dirname(this.filePath), { recursive: true });
+        await writeFile(this.filePath, JSON.stringify({
+            data: encodeValue(this.delegate.data),
+            vectors: encodeValue(this.delegate.vectors),
+        }, null, 2), "utf8");
+    }
+    async batch(operations) {
+        await this.ensureLoaded();
+        const result = await this.delegate.batch(operations);
+        if (operations.some((operation) => "value" in operation)) {
+            await this.persist();
+        }
+        return result;
+    }
+    async get(namespace, key) {
+        await this.ensureLoaded();
+        return this.delegate.get(namespace, key);
+    }
+    async search(namespacePrefix, options) {
+        await this.ensureLoaded();
+        return this.delegate.search(namespacePrefix, options);
+    }
+    async put(namespace, key, value, index) {
+        await this.ensureLoaded();
+        const result = await this.delegate.put(namespace, key, value, index);
+        await this.persist();
+        return result;
+    }
+    async delete(namespace, key) {
+        await this.ensureLoaded();
+        const result = await this.delegate.delete(namespace, key);
+        await this.persist();
+        return result;
+    }
+    async listNamespaces(options) {
+        await this.ensureLoaded();
+        return this.delegate.listNamespaces(options);
+    }
+}
+export function createInMemoryStore() {
+    return new InMemoryStore();
+}

package/dist/runtime/support/embedding-models.d.ts

@@ -0,0 +1,4 @@
+import type { CompiledEmbeddingModel, RuntimeEmbeddingModelResolver, WorkspaceBundle } from "../../contracts/types.js";
+import { type EmbeddingRuntimeLike } from "./llamaindex.js";
+export declare function resolveCompiledEmbeddingModelRef(workspace: WorkspaceBundle, embeddingModelRef?: string): CompiledEmbeddingModel;
+export declare function resolveCompiledEmbeddingModel(embeddingModel: CompiledEmbeddingModel, resolver?: RuntimeEmbeddingModelResolver): Promise<EmbeddingRuntimeLike>;

package/dist/runtime/support/embedding-models.js

@@ -0,0 +1,33 @@
+import { OllamaEmbeddings } from "@langchain/ollama";
+import { compileEmbeddingModel } from "../../workspace/resource-compilers.js";
+import { resolveRefId } from "../../workspace/support/workspace-ref-utils.js";
+import { createLlamaIndexEmbeddingModel } from "./llamaindex.js";
+export function resolveCompiledEmbeddingModelRef(workspace, embeddingModelRef) {
+    const resolvedId = embeddingModelRef ? resolveRefId(embeddingModelRef) : "default";
+    const embeddingModel = workspace.embeddings.get(resolvedId);
+    if (embeddingModel) {
+        return compileEmbeddingModel(embeddingModel);
+    }
+    if (!embeddingModelRef && workspace.embeddings.size === 1) {
+        const soleModel = workspace.embeddings.values().next().value;
+        if (soleModel) {
+            return compileEmbeddingModel(soleModel);
+        }
+    }
+    throw new Error(`Missing embedding model ${embeddingModelRef ?? "embedding-model/default"}`);
+}
+export async function resolveCompiledEmbeddingModel(embeddingModel, resolver) {
+    if (resolver) {
+        return resolver(embeddingModel.id);
+    }
+    if (embeddingModel.provider === "ollama") {
+        return new OllamaEmbeddings({
+            model: embeddingModel.model,
+            ...(embeddingModel.init ?? {}),
+        });
+    }
+    if (embeddingModel.provider === "llamaindex-ollama") {
+        return createLlamaIndexEmbeddingModel(embeddingModel);
+    }
+    throw new Error(`Embedding model provider ${embeddingModel.provider} is not supported by the built-in runtime. Configure embeddingModelResolver or use ollama/llamaindex-ollama.`);
+}

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

@@ -0,0 +1,27 @@
+import type { ApprovalRecord, HarnessEvent, WorkspaceBundle } from "../../contracts/types.js";
+export declare function renderRuntimeFailure(error: unknown): string;
+export declare function parseInterruptContent(content: string): {
+    toolName?: string;
+    toolId?: string;
+    allowedDecisions?: Array<"approve" | "edit" | "reject">;
+    inputPreview?: Record<string, unknown>;
+};
+export declare function requiresResearchRoute(normalizedInput: string): boolean;
+export declare function resolveDeterministicRouteIntent(normalizedInput: string): "primary" | "secondary" | "research" | undefined;
+export declare function heuristicRoute(input: string, primaryBinding?: {
+    agent: {
+        id: string;
+    };
+}, secondaryBinding?: {
+    agent: {
+        id: string;
+    };
+}): string;
+export declare function createHarnessEvent(threadId: string, runId: string, sequence: number, eventType: string, payload: Record<string, unknown>, source?: HarnessEvent["source"]): HarnessEvent;
+export declare function createPendingApproval(threadId: string, runId: string, checkpointRef: string, input: string, interruptContent?: string): ApprovalRecord;
+export declare function inferRoutingBindings(workspace: WorkspaceBundle): {
+    primaryBinding: import("../../contracts/types.js").CompiledAgentBinding;
+    secondaryBinding: import("../../contracts/types.js").CompiledAgentBinding | undefined;
+    researchBinding: import("../../contracts/types.js").CompiledAgentBinding | undefined;
+    hostBindings: import("../../contracts/types.js").CompiledAgentBinding[];
+};

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

@@ -0,0 +1,116 @@
+import { createPersistentId } from "../../utils/id.js";
+export function renderRuntimeFailure(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return `runtime_error=${message}`.trim();
+}
+export function parseInterruptContent(content) {
+    try {
+        const raw = JSON.parse(content);
+        const parsed = Array.isArray(raw) && raw.length > 0 && typeof raw[0] === "object" && raw[0]
+            ? raw[0]
+            : typeof raw === "object" && raw
+                ? raw
+                : {};
+        const allowedDecisions = Array.isArray(parsed.allowedDecisions)
+            ? parsed.allowedDecisions.filter((item) => item === "approve" || item === "edit" || item === "reject")
+            : undefined;
+        return {
+            toolName: typeof parsed.toolName === "string" ? parsed.toolName : undefined,
+            toolId: typeof parsed.toolId === "string" ? parsed.toolId : undefined,
+            allowedDecisions,
+            inputPreview: typeof parsed.inputPreview === "object" && parsed.inputPreview ? parsed.inputPreview : undefined,
+        };
+    }
+    catch {
+        return {};
+    }
+}
+export function requiresResearchRoute(normalizedInput) {
+    return (/\b(latest|recent|today|current|news|headlines|research|compare|comparison|best options?)\b/i.test(normalizedInput) ||
+        /(最新|最近|今天|当前|新闻|头条|研究|调研|比较|对比)/.test(normalizedInput));
+}
+export function resolveDeterministicRouteIntent(normalizedInput) {
+    if (!normalizedInput) {
+        return "primary";
+    }
+    if (requiresResearchRoute(normalizedInput)) {
+        return "research";
+    }
+    if (/^(hi|hello|hey|thanks|thank you|你好|您好|谢谢)\b/.test(normalizedInput)) {
+        return "primary";
+    }
+    if (normalizedInput.length > 240 ||
+        normalizedInput.split(/\n+/).length > 3 ||
+        /\b(create|build|implement|fix|debug|refactor|review|test|ship|release|deploy|code|bug|repo|repository|file|files|download|clone|inspect|analy[sz]e|explore)\b/i.test(normalizedInput) ||
+        /(写代码|实现|修复|排查|调试|重构|评审|测试|发布|部署|仓库|代码|文件|下载|克隆|分析|检查|探索)/.test(normalizedInput)) {
+        return "secondary";
+    }
+    if (/^(what|why|how|when|who|which|explain|summarize|总结|解释|说明|是什么|为什么|怎么|如何)\b/i.test(normalizedInput) &&
+        normalizedInput.length < 160) {
+        return "primary";
+    }
+    return undefined;
+}
+export function heuristicRoute(input, primaryBinding, secondaryBinding) {
+    const normalized = input.trim().toLowerCase();
+    const intent = resolveDeterministicRouteIntent(normalized);
+    if (intent === "research") {
+        return secondaryBinding?.agent.id ?? primaryBinding?.agent.id ?? "agent";
+    }
+    if (intent === "primary") {
+        return primaryBinding?.agent.id ?? "agent";
+    }
+    if (intent === "secondary") {
+        return secondaryBinding?.agent.id ?? primaryBinding?.agent.id ?? "agent";
+    }
+    if (!normalized) {
+        return primaryBinding?.agent.id ?? "agent";
+    }
+    return secondaryBinding?.agent.id ?? primaryBinding?.agent.id ?? "agent";
+}
+export function createHarnessEvent(threadId, runId, sequence, eventType, payload, source = "runtime") {
+    return {
+        eventId: `evt-${String(sequence).padStart(6, "0")}`,
+        eventType,
+        timestamp: new Date().toISOString(),
+        threadId,
+        runId,
+        sequence,
+        source,
+        payload,
+    };
+}
+export function createPendingApproval(threadId, runId, checkpointRef, input, interruptContent) {
+    const requestedAt = new Date().toISOString();
+    const interrupt = interruptContent ? parseInterruptContent(interruptContent) : {};
+    const approvalId = `approval-${createPersistentId()}`;
+    return {
+        approvalId,
+        pendingActionId: approvalId,
+        threadId,
+        runId,
+        toolCallId: interrupt.toolId ?? `tool-${runId}`,
+        toolName: interrupt.toolName ?? "write_file",
+        status: "pending",
+        requestedAt,
+        resolvedAt: null,
+        allowedDecisions: interrupt.allowedDecisions ?? ["approve", "edit", "reject"],
+        inputPreview: interrupt.inputPreview ?? { input },
+        checkpointRef,
+        eventRefs: ["000003.json", "000004.json"],
+    };
+}
+export function inferRoutingBindings(workspace) {
+    const hostBindings = Array.from(workspace.bindings.values()).filter((binding) => binding.harnessRuntime.hostFacing);
+    const researchBinding = hostBindings.find((binding) => binding.agent.id === "research-lite" || binding.agent.id === "research");
+    const directBinding = hostBindings.find((binding) => binding.agent.id === "direct");
+    const langchainHost = hostBindings.find((binding) => binding.agent.executionMode === "langchain-v1" && binding.agent.id !== researchBinding?.agent.id);
+    const deepagentHosts = hostBindings.filter((binding) => binding.agent.executionMode === "deepagent");
+    const deepagentWithSubagents = deepagentHosts.find((binding) => (binding.deepAgentParams?.subagents.length ?? 0) > 0) ??
+        deepagentHosts[0];
+    const primaryBinding = directBinding ?? langchainHost ?? hostBindings[0];
+    const secondaryBinding = deepagentWithSubagents && deepagentWithSubagents.agent.id !== primaryBinding?.agent.id
+        ? deepagentWithSubagents
+        : hostBindings.find((binding) => binding.agent.id !== primaryBinding?.agent.id);
+    return { primaryBinding, secondaryBinding, researchBinding, hostBindings };
+}

package/dist/runtime/support/index.d.ts

@@ -0,0 +1,4 @@
+export { createHarnessEvent, createPendingApproval, heuristicRoute, inferRoutingBindings, parseInterruptContent, renderRuntimeFailure, requiresResearchRoute, } from "./harness-support.js";
+export { resolveCompiledEmbeddingModel, resolveCompiledEmbeddingModelRef } from "./embedding-models.js";
+export { createCheckpointerForConfig, createStoreForConfig } from "./runtime-factories.js";
+export { resolveCompiledVectorStore, resolveCompiledVectorStoreRef } from "./vector-stores.js";

package/dist/runtime/support/index.js

@@ -0,0 +1,4 @@
+export { createHarnessEvent, createPendingApproval, heuristicRoute, inferRoutingBindings, parseInterruptContent, renderRuntimeFailure, requiresResearchRoute, } from "./harness-support.js";
+export { resolveCompiledEmbeddingModel, resolveCompiledEmbeddingModelRef } from "./embedding-models.js";
+export { createCheckpointerForConfig, createStoreForConfig } from "./runtime-factories.js";
+export { resolveCompiledVectorStore, resolveCompiledVectorStoreRef } from "./vector-stores.js";

package/dist/runtime/support/llamaindex.d.ts

@@ -0,0 +1,24 @@
+import type { CompiledEmbeddingModel, CompiledVectorStore } from "../../contracts/types.js";
+export type EmbeddingRuntimeLike = {
+    embedDocuments: (texts: string[]) => Promise<number[][]>;
+    embedQuery: (text: string) => Promise<number[]>;
+};
+export type VectorStoreRuntimeLike = {
+    kind: string;
+    embeddingModelRef?: string;
+    addDocuments: (documents: Array<{
+        pageContent: string;
+        metadata?: Record<string, unknown>;
+    }>) => Promise<string[]>;
+    similaritySearch: (query: string, limit: number) => Promise<Array<{
+        pageContent: string;
+        metadata?: Record<string, unknown>;
+        score?: number;
+    }>>;
+    delete: (params: {
+        deleteAll?: boolean;
+        ids?: string[];
+    }) => Promise<void>;
+};
+export declare function createLlamaIndexEmbeddingModel(embeddingModel: CompiledEmbeddingModel): EmbeddingRuntimeLike;
+export declare function createLlamaIndexVectorStore(workspaceRoot: string, vectorStore: CompiledVectorStore, embeddings: EmbeddingRuntimeLike): Promise<VectorStoreRuntimeLike>;