@botbotgo/agent-harness 0.0.329 → 0.0.332

package/dist/package-version.d.ts

@@ -1,2 +1,2 @@
-export declare const AGENT_HARNESS_VERSION = "0.0.328";
+export declare const AGENT_HARNESS_VERSION = "0.0.331";
 export declare const AGENT_HARNESS_RELEASE_DATE = "2026-04-23";

package/dist/package-version.js

@@ -1,2 +1,2 @@
-export const AGENT_HARNESS_VERSION = "0.0.328";
+export const AGENT_HARNESS_VERSION = "0.0.331";
 export const AGENT_HARNESS_RELEASE_DATE = "2026-04-23";

package/dist/runtime/adapter/flow/stream-runtime.js

@@ -148,7 +148,14 @@ export async function* streamRuntimeExecution(options) {
     const shouldDeferStreamContent = () => shouldValidateStreamOutput && !emittedUnsafeStreamSideEffects;
     const flushDeferredStreamContent = async function* () {
         while (deferredStreamContent.length > 0) {
-            yield deferredStreamContent.shift();
+            const next = deferredStreamContent.shift();
+            if (next.kind === "content") {
+                if (next.content) {
+                    yield { kind: "content", content: next.content };
+                }
+                continue;
+            }
+            yield next;
         }
     };
     try {

package/dist/runtime/adapter/invocation-result.d.ts

@@ -5,6 +5,13 @@ export type ExecutedToolResult = {
     isError?: boolean;
     memoryCandidates?: MemoryCandidate[];
 };
+export declare function resolveDeterministicFinalOutput(params: {
+    visibleOutput?: string;
+    toolFallback?: string;
+    executedToolResults?: ExecutedToolResult[];
+}): string;
+export declare function extractDelegatedFindingsText(executedToolResults: ExecutedToolResult[]): string;
+export declare function extractToolResultFindingsText(executedToolResults: ExecutedToolResult[]): string;
 export declare function finalizeRequestResult(params: {
     bindingAgentId: string;
     sessionId: string;

package/dist/runtime/adapter/invocation-result.js

@@ -1,6 +1,95 @@
 import { containsLikelySkillDocument, extractContentBlocks, extractEmptyAssistantMessageFailure, extractOutputContent, extractToolFallbackContext, extractVisibleOutput, isLikelyToolArgsObject, sanitizeVisibleText, tryParseJson, } from "../parsing/output-parsing.js";
+import { salvageFunctionLikeToolCall } from "../parsing/output-tool-args.js";
 import { buildStateSnapshot } from "./model/message-assembly.js";
 import { asRecord } from "./tool/resolved-tool.js";
+function looksLikeLeakedToolCallText(value) {
+    const normalized = sanitizeVisibleText(value).trim();
+    if (!normalized) {
+        return false;
+    }
+    if (salvageFunctionLikeToolCall(normalized)) {
+        return true;
+    }
+    const prefixedToolCallMatch = /^(?:\s*(?:Ready|Understood|Okay|Ok|Got it|Sure|All set|What is your request|Please provide a task for me to orchestrate)[.:?!]?\s*)+([A-Za-z_][A-Za-z0-9_]*\([\s\S]*\))\s*$/u.exec(normalized);
+    return !!(prefixedToolCallMatch && salvageFunctionLikeToolCall(prefixedToolCallMatch[1]));
+}
+function isPlaceholderTaskCompletion(value) {
+    const normalized = sanitizeVisibleText(value).trim();
+    return normalized === "Task completed";
+}
+function normalizeToolOutputText(output) {
+    const directText = typeof output === "string"
+        ? sanitizeVisibleText(output).trim()
+        : "";
+    if (directText && !looksLikeLeakedToolCallText(directText) && !isPlaceholderTaskCompletion(directText)) {
+        return directText;
+    }
+    const visibleOutput = sanitizeVisibleText(extractVisibleOutput(output)).trim();
+    if (visibleOutput && !looksLikeLeakedToolCallText(visibleOutput) && !isPlaceholderTaskCompletion(visibleOutput)) {
+        return visibleOutput;
+    }
+    const fallbackContext = sanitizeVisibleText(extractToolFallbackContext(output)).trim();
+    if (fallbackContext && !looksLikeLeakedToolCallText(fallbackContext) && !isPlaceholderTaskCompletion(fallbackContext)) {
+        return fallbackContext;
+    }
+    return "";
+}
+function extractLatestSuccessfulTaskResultText(executedToolResults) {
+    for (const toolResult of [...executedToolResults].reverse()) {
+        if (toolResult.isError === true || toolResult.toolName !== "task") {
+            continue;
+        }
+        const normalized = normalizeToolOutputText(toolResult.output);
+        if (normalized) {
+            return normalized;
+        }
+    }
+    return "";
+}
+function extractLatestSuccessfulNonTodoToolResultText(executedToolResults) {
+    for (const toolResult of [...executedToolResults].reverse()) {
+        if (toolResult.isError === true) {
+            continue;
+        }
+        if (toolResult.toolName === "task" || toolResult.toolName === "write_todos" || toolResult.toolName === "read_todos") {
+            continue;
+        }
+        const normalized = normalizeToolOutputText(toolResult.output);
+        if (normalized) {
+            return normalized;
+        }
+    }
+    return "";
+}
+export function resolveDeterministicFinalOutput(params) {
+    const visibleOutput = params.visibleOutput ?? "";
+    const toolFallback = params.toolFallback ?? "";
+    const executedToolResults = params.executedToolResults ?? [];
+    const delegatedTaskOutput = extractLatestSuccessfulTaskResultText(executedToolResults);
+    if (delegatedTaskOutput) {
+        return delegatedTaskOutput;
+    }
+    const sanitizedVisibleOutput = visibleOutput && !looksLikeLeakedToolCallText(visibleOutput)
+        ? sanitizeVisibleText(visibleOutput).trim()
+        : "";
+    if (sanitizedVisibleOutput) {
+        return sanitizedVisibleOutput;
+    }
+    const successfulToolOutput = extractLatestSuccessfulNonTodoToolResultText(executedToolResults);
+    if (successfulToolOutput) {
+        return successfulToolOutput;
+    }
+    const sanitizedToolFallback = toolFallback && !looksLikeLeakedToolCallText(toolFallback)
+        ? sanitizeVisibleText(toolFallback).trim()
+        : "";
+    return sanitizedToolFallback;
+}
+export function extractDelegatedFindingsText(executedToolResults) {
+    return extractLatestSuccessfulTaskResultText(executedToolResults);
+}
+export function extractToolResultFindingsText(executedToolResults) {
+    return extractLatestSuccessfulNonTodoToolResultText(executedToolResults);
+}
 export function finalizeRequestResult(params) {
     const { bindingAgentId, sessionId, requestId, result, executedToolResults } = params;
     const interruptContent = Array.isArray(result.__interrupt__) && result.__interrupt__.length > 0 ? JSON.stringify(result.__interrupt__) : undefined;
@@ -12,7 +101,12 @@ export function finalizeRequestResult(params) {
         throw new Error(emptyAssistantMessageFailure);
     }
     const serializedResult = JSON.stringify(result, null, 2);
-    const output = visibleOutput || toolFallback || (containsLikelySkillDocument(result) ? "" : serializedResult);
+    const output = resolveDeterministicFinalOutput({
+        visibleOutput,
+        toolFallback,
+        executedToolResults,
+    })
+        || (containsLikelySkillDocument(result) ? "" : serializedResult);
     const finalMessageText = sanitizeVisibleText(output);
     const outputContent = extractOutputContent(result);
     const contentBlocks = extractContentBlocks(result);

package/dist/runtime/adapter/middleware-assembly.js

@@ -12,6 +12,7 @@ import { materializeDeepAgentSkillSourcePaths } from "./compat/deepagent-compat.
 import { DEFAULT_SUBAGENT_PROMPT } from "../prompts/runtime-prompts.js";
 import { AUTONOMOUS_INVESTIGATION_RECOVERY_INSTRUCTION } from "../prompts/runtime-prompts.js";
 import { createStreamEventProjectionState, projectRuntimeStreamEvent } from "./stream-event-projection.js";
+import { resolveDeterministicFinalOutput } from "./invocation-result.js";
 const EMPTY_TOOL_NAME_MAPPING = {
     originalToModelFacing: new Map(),
     modelFacingToOriginal: new Map(),
@@ -268,9 +269,10 @@ export async function invokeBuiltinTaskTool(input) {
     if (typeof runnable.streamEvents === "function") {
         const runWithStreamInspection = async (recoveryInstruction) => {
             const projectionState = createStreamEventProjectionState();
+            const executedToolResults = [];
             const events = await runnable.streamEvents(buildMessages(recoveryInstruction), invokeConfig);
             for await (const event of events) {
-                projectRuntimeStreamEvent({
+                const projectedChunks = projectRuntimeStreamEvent({
                     event,
                     allowVisibleStreamDeltas: false,
                     includeStateStreamOutput: false,
@@ -280,15 +282,25 @@ export async function invokeBuiltinTaskTool(input) {
                     primaryTools: [],
                     state: projectionState,
                 });
+                for (const chunk of projectedChunks) {
+                    if (chunk.kind !== "tool-result") {
+                        continue;
+                    }
+                    executedToolResults.push({
+                        toolName: chunk.toolName,
+                        output: chunk.output,
+                        isError: chunk.isError,
+                    });
+                }
             }
-            return projectionState;
+            return { projectionState, executedToolResults };
         };
-        let projectionState = await runWithStreamInspection();
+        let { projectionState, executedToolResults } = await runWithStreamInspection();
         if (requiresDelegatedExecutionRecovery(projectionState)) {
             const recoveryInstruction = projectionState.hasIncompletePlanState && projectionState.emittedToolError
                 ? `${AUTONOMOUS_INVESTIGATION_RECOVERY_INSTRUCTION}\n\n${DELEGATED_FAILURE_PLAN_RECONCILIATION_INSTRUCTION}`
                 : AUTONOMOUS_INVESTIGATION_RECOVERY_INSTRUCTION;
-            projectionState = await runWithStreamInspection(recoveryInstruction);
+            ({ projectionState, executedToolResults } = await runWithStreamInspection(recoveryInstruction));
         }
         if (requiresDelegatedExecutionRecovery(projectionState)) {
             throw new Error(formatDelegatedExecutionBlocker(projectionState));
@@ -297,14 +309,20 @@ export async function invokeBuiltinTaskTool(input) {
             throw new Error("Delegated investigation ended without any real tool execution evidence.");
         }
         if (projectionState.emittedToolError) {
-            const blockerMessage = projectionState.emittedOutput.trim()
-                || formatDelegatedExecutionBlocker(projectionState);
+            const blockerMessage = resolveDeterministicFinalOutput({
+                visibleOutput: projectionState.emittedOutput.trim(),
+                executedToolResults,
+            }) || formatDelegatedExecutionBlocker(projectionState);
             if (hasUnresolvedDelegatedExecution(projectionState) || !projectionState.emittedSuccessfulToolResult) {
                 throw new Error(blockerMessage);
             }
         }
-        if (projectionState.emittedOutput.trim()) {
-            return projectionState.emittedOutput.trim();
+        const deterministicOutput = resolveDeterministicFinalOutput({
+            visibleOutput: projectionState.emittedOutput.trim(),
+            executedToolResults,
+        });
+        if (deterministicOutput) {
+            return deterministicOutput;
         }
         if (projectionState.emittedToolResult) {
             throw new Error("Delegated investigation performed tool work but did not return surfaced findings.");

package/dist/runtime/adapter/model/model-providers.js

@@ -415,7 +415,7 @@ async function createNodeLlamaCppModel(model) {
         }));
     }
     catch (error) {
-        throw new Error(`Failed to initialize ${model.provider} model ${model.id}. Install node-llama-cpp in the application workspace and ensure the GGUF file exists at ${modelPath}.`, { cause: error });
+        throw new Error(`Failed to initialize ${model.provider} model ${model.id}. Install @langchain/community and node-llama-cpp in the application workspace and ensure the GGUF file exists at ${modelPath}.`, { cause: error });
     }
 }
 export async function createResolvedModel(model, modelResolver) {

package/dist/runtime/adapter/stream-event-projection.js

@@ -1,4 +1,5 @@
 import { sanitizeVisibleText } from "../parsing/output-parsing.js";
+import { salvageFunctionLikeToolCall } from "../parsing/output-tool-args.js";
 import { computeIncrementalOutput, extractInterruptPayload, extractReasoningStreamOutput, sanitizeRetainedUpstreamEvent, extractStateStreamOutput, extractTerminalStreamOutput, extractToolResult, extractVisibleStreamOutput, normalizeTerminalOutputKey, } from "../parsing/stream-event-parsing.js";
 import { resolveModelFacingToolName } from "./tool/tool-name-mapping.js";
 export function createStreamEventProjectionState() {
@@ -24,6 +25,20 @@ export function createStreamEventProjectionState() {
         seenTerminalOutputs: new Set(),
     };
 }
+function shouldSuppressVisibleToolCallText(value) {
+    const trimmed = value.trim();
+    if (!trimmed) {
+        return false;
+    }
+    if (salvageFunctionLikeToolCall(trimmed)) {
+        return true;
+    }
+    const prefixedToolCallMatch = /^(?:\s*(?:Ready|Understood|Okay|Ok|Got it|Sure|All set)[.:!]?\s*)+([A-Za-z_][A-Za-z0-9_]*\([\s\S]*\))\s*$/u.exec(trimmed);
+    if (!prefixedToolCallMatch) {
+        return false;
+    }
+    return salvageFunctionLikeToolCall(prefixedToolCallMatch[1]) !== null;
+}
 function readSummaryCounts(summary) {
     if (typeof summary !== "object" || summary === null) {
         return null;
@@ -218,7 +233,7 @@ export function projectRuntimeStreamEvent(params) {
     const allowStreamedVisibleContent = allowVisibleContent && !state.emittedToolResult && !state.emittedToolError;
     if (allowVisibleStreamDeltas && allowStreamedVisibleContent) {
         const visibleStreamOutput = extractVisibleStreamOutput(event);
-        if (visibleStreamOutput) {
+        if (visibleStreamOutput && !shouldSuppressVisibleToolCallText(visibleStreamOutput)) {
             const nextOutput = computeIncrementalOutput(state.emittedOutput, visibleStreamOutput);
             state.emittedOutput = nextOutput.accumulated;
             if (nextOutput.delta) {
@@ -228,8 +243,8 @@ export function projectRuntimeStreamEvent(params) {
     }
     if (includeStateStreamOutput && allowVisibleContent) {
         const stateStreamOutput = extractStateStreamOutput(event);
-        if (stateStreamOutput) {
-            const nextOutput = computeIncrementalOutput(state.emittedOutput, sanitizeVisibleText(stateStreamOutput));
+        if (stateStreamOutput && !shouldSuppressVisibleToolCallText(stateStreamOutput)) {
+            const nextOutput = computeIncrementalOutput(state.emittedOutput, stateStreamOutput);
             state.emittedOutput = nextOutput.accumulated;
             if (nextOutput.delta) {
                 chunks.push({ kind: "content", content: nextOutput.delta });
@@ -269,7 +284,7 @@ export function projectRuntimeStreamEvent(params) {
             state.emittedDelegatedTerminalOutput = true;
         }
     }
-    if (output) {
+    if (output && !shouldSuppressVisibleToolCallText(output)) {
         const outputKey = normalizeTerminalOutputKey(output);
         if (!outputKey || !state.seenTerminalOutputs.has(outputKey)) {
             if (outputKey) {

package/dist/runtime/harness/run/stream-run.js

@@ -1,6 +1,8 @@
+import { resolveDeterministicFinalOutput, } from "../../adapter/invocation-result.js";
 import { AGENT_INTERRUPT_SENTINEL_PREFIX, RuntimeOperationTimeoutError } from "../../agent-runtime-adapter.js";
 import { ExecutionReconciliationError } from "../../adapter/flow/stream-runtime.js";
 import { buildRequestPlanState, summarizeBuiltinWriteTodosArgs } from "../../adapter/runtime-adapter-support.js";
+import { sanitizeVisibleText } from "../../parsing/output-parsing.js";
 import { describeRuntimeError, renderRuntimeFailure, renderToolFailure } from "../../support/harness-support.js";
 import { getBindingPrimaryModel } from "../../support/compiled-binding.js";
 import { createContentBlocksItem, createToolResultKey, } from "../events/streaming.js";
@@ -466,7 +468,9 @@ export async function* streamHarnessRun(options) {
         ]).then(([loadedPriorHistory, resolvedReleaseRunSlot]) => [loadedPriorHistory, resolvedReleaseRunSlot]);
         releaseRunSlot = acquiredReleaseRunSlot;
         const toolErrors = [];
+        let sawSuccessfulToolResult = false;
         let lastToolResultKey = null;
+        const executedToolResults = [];
         const recalledMemories = options.invocation.memoryRecall?.items ?? [];
         for (const item of createRuntimeMemoryRecallSteps(options.sessionId, options.requestId, recalledMemories)) {
             yield item;
@@ -637,9 +641,17 @@ export async function* streamHarnessRun(options) {
                     continue;
                 }
                 lastToolResultKey = toolResultKey;
+                executedToolResults.push({
+                    toolName: normalizedChunk.toolName,
+                    output: normalizedChunk.output,
+                    isError: normalizedChunk.isError,
+                });
                 if (normalizedChunk.isError) {
                     toolErrors.push(renderToolFailure(normalizedChunk.toolName, normalizedChunk.output));
                 }
+                else {
+                    sawSuccessfulToolResult = true;
+                }
                 yield {
                     type: "tool-result",
                     sessionId: options.sessionId,
@@ -714,10 +726,18 @@ export async function* streamHarnessRun(options) {
                 content: normalizedChunk.content,
             };
         }
-        if (!assistantOutput && toolErrors.length > 0) {
+        if (!assistantOutput && toolErrors.length > 0 && !sawSuccessfulToolResult) {
             assistantOutput = toolErrors.join("\n\n");
             emitted = true;
         }
+        const resolvedAssistantOutput = resolveDeterministicFinalOutput({
+            visibleOutput: assistantOutput,
+            executedToolResults,
+        });
+        if (sanitizeVisibleText(resolvedAssistantOutput) !== sanitizeVisibleText(assistantOutput)) {
+            assistantOutput = resolvedAssistantOutput;
+            emitted = emitted || assistantOutput.length > 0;
+        }
         currentPlanState = await refreshPlanStateFromPersistence(options, currentPlanState);
         if (!assistantOutput) {
             const actual = await options.invokeWithHistory(options.binding, options.input, options.sessionId, options.requestId);

package/dist/runtime/harness/system/mem0-ingestion-sync.d.ts

@@ -1,4 +1,3 @@
-import { type Memory as Mem0Memory, type Message as Mem0Message } from "mem0ai";
 import type { HarnessEvent, HarnessEventProjection } from "../../../contracts/types.js";
 import type { RuntimePersistence } from "../../../persistence/types.js";
 import { type StoreLike } from "./store.js";
@@ -17,6 +16,24 @@ export type ResolvedMem0Config = {
     writeOnApprovalResolution: boolean;
     writeOnRequestCompletion: boolean;
 };
+type Mem0Message = {
+    role: string;
+    content: string;
+};
+type Mem0Memory = {
+    id?: string;
+    memory?: string;
+    data?: {
+        memory?: string;
+    };
+    score?: number;
+    categories?: string[];
+    metadata?: Record<string, unknown>;
+    agent_id?: string;
+    request_id?: string;
+    created_at?: string | Date;
+    updated_at?: string | Date;
+};
 type Mem0ClientLike = {
     add(messages: Mem0Message[], options?: Record<string, unknown>): Promise<unknown>;
     search(query: string, options?: Record<string, unknown>): Promise<Mem0Memory[]>;

package/dist/runtime/harness/system/mem0-ingestion-sync.js

@@ -1,6 +1,5 @@
 import { createHash } from "node:crypto";
 import path from "node:path";
-import { MemoryClient } from "mem0ai";
 import { extractMessageText } from "../../../utils/message-content.js";
 import { FileBackedStore } from "./store.js";
 const MEM0_EVENT_TYPES = new Set([
@@ -79,27 +78,24 @@ async function createDefaultMem0Client(config) {
     if (!apiKey) {
         throw new Error(`runtimeMemory.mem0 is enabled but environment variable ${config.apiKeyEnv} is not set`);
     }
-    return new MemoryClient({
-        apiKey,
-        ...(config.host ? { host: config.host } : {}),
-        ...(config.organizationName ? { organizationName: config.organizationName } : {}),
-        ...(config.projectName ? { projectName: config.projectName } : {}),
-        ...(config.organizationId ? { organizationId: config.organizationId } : {}),
-        ...(config.projectId ? { projectId: config.projectId } : {}),
-    });
+    return createCloudMem0Client(config, apiKey);
 }
 function normalizeMem0Host(host) {
     return host.replace(/\/+$/, "");
 }
+function buildMem0Headers(apiKey) {
+    return {
+        "Content-Type": "application/json",
+        ...(apiKey ? { Authorization: `Token ${apiKey}` } : {}),
+    };
+}
 async function selfHostedMem0Request(config, pathname, options = {}) {
     if (!config.host) {
         throw new Error("Self-hosted mem0 client requires runtimeMemory.mem0.host.");
     }
     const response = await fetch(`${normalizeMem0Host(config.host)}${pathname}`, {
         method: options.method ?? "GET",
-        headers: {
-            "Content-Type": "application/json",
-        },
+        headers: buildMem0Headers(),
         ...(options.body ? { body: JSON.stringify(options.body) } : {}),
     });
     if (!response.ok) {
@@ -107,6 +103,54 @@ async function selfHostedMem0Request(config, pathname, options = {}) {
     }
     return response.json();
 }
+function applyMem0Scope(payload, config) {
+    const scoped = { ...payload };
+    if (config.organizationName && config.projectName) {
+        scoped.org_name = config.organizationName;
+        scoped.project_name = config.projectName;
+    }
+    if (config.organizationId && config.projectId) {
+        scoped.org_id = config.organizationId;
+        scoped.project_id = config.projectId;
+        delete scoped.org_name;
+        delete scoped.project_name;
+    }
+    return scoped;
+}
+async function cloudMem0Request(config, apiKey, pathname, options = {}) {
+    const host = normalizeMem0Host(config.host ?? "https://api.mem0.ai");
+    const response = await fetch(`${host}${pathname}`, {
+        method: options.method ?? "GET",
+        headers: buildMem0Headers(apiKey),
+        ...(options.body ? { body: JSON.stringify(applyMem0Scope(options.body, config)) } : {}),
+    });
+    if (!response.ok) {
+        throw new Error(`Mem0 request failed: ${response.status} ${response.statusText}`);
+    }
+    return response.json();
+}
+function createCloudMem0Client(config, apiKey) {
+    return {
+        async add(messages, options = {}) {
+            return cloudMem0Request(config, apiKey, "/v1/memories/", {
+                method: "POST",
+                body: {
+                    messages,
+                    ...options,
+                },
+            });
+        },
+        async search(query, options = {}) {
+            return cloudMem0Request(config, apiKey, "/v1/memories/search/", {
+                method: "POST",
+                body: {
+                    query,
+                    ...options,
+                },
+            });
+        },
+    };
+}
 function createSelfHostedMem0Client(config) {
     return {
         async add(messages, options = {}) {
@@ -275,7 +319,7 @@ export class Mem0SemanticRecall {
             const createdAt = toIsoString(record.created_at) ?? new Date(0).toISOString();
             const updatedAt = toIsoString(record.updated_at) ?? createdAt;
             return {
-                id: record.id,
+                id: typeof record.id === "string" && record.id.trim().length > 0 ? record.id : memory,
                 memory,
                 score: typeof record.score === "number" && Number.isFinite(record.score) ? record.score : 0,
                 categories: Array.isArray(record.categories)

package/dist/runtime/parsing/output-content.js

@@ -1,11 +1,93 @@
 import { AIMessage } from "langchain";
 import { salvageFunctionLikeToolCall, salvageToolArgs, isLikelyToolArgsObject, normalizeKnownToolArgs, tryParseJson } from "./output-tool-args.js";
+function consumeLeadingFunctionLikeToolCall(value) {
+    const match = /^([A-Za-z_][A-Za-z0-9_]*)\(/.exec(value);
+    if (!match) {
+        return null;
+    }
+    let depthParen = 0;
+    let depthBracket = 0;
+    let depthBrace = 0;
+    let inString = false;
+    let quoteChar = "";
+    let escaping = false;
+    for (let index = match[0].length - 1; index < value.length; index += 1) {
+        const char = value[index];
+        if (inString) {
+            if (escaping) {
+                escaping = false;
+                continue;
+            }
+            if (char === "\\") {
+                escaping = true;
+                continue;
+            }
+            if (char === quoteChar) {
+                inString = false;
+                quoteChar = "";
+            }
+            continue;
+        }
+        if (char === "\"" || char === "'") {
+            inString = true;
+            quoteChar = char;
+            continue;
+        }
+        if (char === "(") {
+            depthParen += 1;
+            continue;
+        }
+        if (char === ")") {
+            depthParen -= 1;
+            if (depthParen === 0 && depthBracket === 0 && depthBrace === 0) {
+                const candidate = value.slice(0, index + 1);
+                return salvageFunctionLikeToolCall(candidate) ? candidate : null;
+            }
+            continue;
+        }
+        if (char === "[")
+            depthBracket += 1;
+        else if (char === "]")
+            depthBracket -= 1;
+        else if (char === "{")
+            depthBrace += 1;
+        else if (char === "}")
+            depthBrace -= 1;
+    }
+    return null;
+}
+function stripVisibleFunctionLikeToolCallText(value) {
+    let remaining = value.trim();
+    let removedLeadingCall = false;
+    while (remaining.length > 0) {
+        const consumed = consumeLeadingFunctionLikeToolCall(remaining);
+        if (!consumed) {
+            break;
+        }
+        removedLeadingCall = true;
+        remaining = remaining.slice(consumed.length).trimStart();
+    }
+    const lineFiltered = remaining
+        .split("\n")
+        .map((line) => line.trim())
+        .filter((line) => !salvageFunctionLikeToolCall(line))
+        .join("\n")
+        .trim();
+    if (lineFiltered.length > 0) {
+        const prefixedToolCallMatch = /^(?:\s*(?:Ready|Understood|Okay|Ok|Got it|Sure|All set|Please provide a task for me to orchestrate)[.:!]?\s*)+([A-Za-z_][A-Za-z0-9_]*\([\s\S]*\))\s*$/u.exec(lineFiltered);
+        if (prefixedToolCallMatch && salvageFunctionLikeToolCall(prefixedToolCallMatch[1])) {
+            return "";
+        }
+        return lineFiltered;
+    }
+    return removedLeadingCall ? "" : value.trim();
+}
 export function sanitizeVisibleText(value) {
-    return value
+    return stripVisibleFunctionLikeToolCallText(value
         .replace(/[A-Za-z0-9_]*Middleware\.after_model/g, "")
         .replace(/todoListMiddleware\.after_model/g, "")
         .replace(/__end__+/g, "")
-        .trim();
+        .trim());
 }
 function isLikelyMemoryWriteArgsObject(value) {
     if (typeof value !== "object" || !value || Array.isArray(value)) {
@@ -104,7 +186,7 @@ function extractAssistantTextFromMessages(messages) {
             const content = extractMessageContent(message);
             if (content)
                 return content;
-            continue;
+            return "";
         }
         const ids = Array.isArray(typed.id) ? typed.id.filter((item) => typeof item === "string") : [];
         const typeName = ids.at(-1);
@@ -123,6 +205,7 @@ function extractAssistantTextFromMessages(messages) {
         const content = extractMessageContent(message);
         if (content)
             return content;
+        return "";
     }
     return "";
 }

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

@@ -65,7 +65,7 @@ async function createNodeLlamaCppEmbeddings(embeddingModel) {
         });
     }
     catch (error) {
-        throw new Error(`Failed to initialize ${embeddingModel.provider} embedding model ${embeddingModel.id}. Install node-llama-cpp in the application workspace and ensure the GGUF file exists at ${modelPath}.`, { cause: error });
+        throw new Error(`Failed to initialize ${embeddingModel.provider} embedding model ${embeddingModel.id}. Install @langchain/community and node-llama-cpp in the application workspace and ensure the GGUF file exists at ${modelPath}.`, { cause: error });
     }
 }
 async function createLazyLlamaIndexEmbeddingModel(embeddingModel) {

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

@@ -1,8 +1,6 @@
 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 { QdrantClient } from "@qdrant/js-client-rest";
 import { compileVectorStore } from "../../workspace/resource-compilers.js";
 import { getRuntimeStorageRoots, resolveRefId } from "../../workspace/support/workspace-ref-utils.js";
@@ -52,6 +50,69 @@ async function ensureLibSqlSchema(db, table, column, dimensions) {
     ON ${safeTable}(libsql_vector_idx(${safeColumn}))
   `);
 }
+function serializeVector(vector) {
+    if (!vector.every((value) => typeof value === "number" && Number.isFinite(value))) {
+        throw new Error("Invalid vector: all elements must be finite numbers.");
+    }
+    return `[${vector.join(",")}]`;
+}
+async function addLibSqlDocuments(db, table, column, documents, vectors) {
+    const safeTable = assertIdentifier(table, "table name");
+    const safeColumn = assertIdentifier(column, "column name");
+    const statements = documents.map((document, index) => ({
+        sql: `INSERT INTO ${safeTable} (content, metadata, ${safeColumn}) VALUES (:content, :metadata, vector(:embedding)) RETURNING ${safeTable}.rowid AS id`,
+        args: {
+            content: document.pageContent,
+            metadata: JSON.stringify(document.metadata ?? {}),
+            embedding: serializeVector(vectors[index] ?? []),
+        },
+    }));
+    if (statements.length === 0) {
+        return [];
+    }
+    const results = await db.batch(statements);
+    return results.flatMap((result) => result.rows.map((row) => String(row.id)));
+}
+async function similaritySearchLibSql(db, table, column, queryVector, limit) {
+    const safeTable = assertIdentifier(table, "table name");
+    const safeColumn = assertIdentifier(column, "column name");
+    const safeIndex = assertIdentifier(`idx_${safeTable}_${safeColumn}`, "index name");
+    const rows = await db.execute({
+        sql: `SELECT ${safeTable}.rowid AS id, ${safeTable}.content, ${safeTable}.metadata, vector_distance_cos(${safeTable}.${safeColumn}, vector(:queryVector)) AS distance
+      FROM vector_top_k('${safeIndex}', vector(:queryVector), CAST(:limit AS INTEGER)) AS top_k
+      JOIN ${safeTable} ON top_k.rowid = ${safeTable}.rowid`,
+        args: {
+            queryVector: serializeVector(queryVector),
+            limit,
+        },
+    });
+    return rows.rows.map((row) => {
+        const parsedMetadata = typeof row.metadata === "string" ? JSON.parse(row.metadata) : {};
+        const metadata = typeof parsedMetadata === "object" && parsedMetadata && !Array.isArray(parsedMetadata)
+            ? parsedMetadata
+            : {};
+        return {
+            pageContent: typeof row.content === "string" ? row.content : "",
+            metadata,
+            score: typeof row.distance === "number" ? 1 - row.distance : undefined,
+        };
+    });
+}
+async function deleteLibSqlVectors(db, table, params) {
+    const safeTable = assertIdentifier(table, "table name");
+    if (params.deleteAll) {
+        await db.execute(`DELETE FROM ${safeTable}`);
+        return;
+    }
+    const ids = params.ids ?? [];
+    if (ids.length === 0) {
+        throw new Error('You must provide an "ids" parameter or a "deleteAll" parameter.');
+    }
+    await db.batch(ids.map((id) => ({
+        sql: `DELETE FROM ${safeTable} WHERE rowid = :id`,
+        args: { id },
+    })));
+}
 function createQdrantClientForStore(vectorStore) {
     return new QdrantClient({
         ...(vectorStore.url ? { url: vectorStore.url } : {}),
@@ -197,35 +258,17 @@ export async function resolveCompiledVectorStore(workspace, vectorStore, options
         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)));
+            const vectors = await embeddings.embedDocuments(documents.map((document) => document.pageContent));
+            return addLibSqlDocuments(db, table, column, documents, vectors);
         },
         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,
-            }));
+            const queryVector = await embeddings.embedQuery(query);
+            return similaritySearchLibSql(db, table, column, queryVector, limit);
         },
         delete: async (params) => {
             await ensureSchemaForTexts(["seed"]);
-            const store = new LibSQLVectorStore(embeddings, {
-                db,
-                table,
-                column,
-            });
-            await store.delete(params);
+            await deleteLibSqlVectors(db, table, params);
         },
     };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@botbotgo/agent-harness",
-  "version": "0.0.329",
+  "version": "0.0.332",
   "description": "Workspace runtime for multi-agent applications",
   "license": "MIT",
   "type": "module",
@@ -48,7 +48,6 @@
   },
   "dependencies": {
     "@langchain/anthropic": "^1.3.27",
-    "@langchain/community": "^1.1.27",
     "@langchain/core": "^1.1.41",
     "@langchain/google": "^0.1.10",
     "@langchain/langgraph": "^1.2.9",
@@ -61,7 +60,6 @@
     "deepagents": "^1.9.0",
     "langchain": "^1.3.4",
     "llamaindex": "^0.12.1",
-    "mem0ai": "^2.4.6",
     "mustache": "^4.2.0",
     "yaml": "^2.8.1",
     "zod": "^3.25.76"
@@ -89,6 +87,7 @@
     "release:publish": "npm publish --access public --registry https://registry.npmjs.org/"
   },
   "devDependencies": {
+    "@langchain/community": "^1.1.27",
     "@types/node": "^25.5.2",
     "typescript": "^6.0.2",
     "vite": "^7.3.2",