@botbotgo/agent-harness 0.0.127 → 0.0.129

package/dist/config/runtime/runtime-memory.yaml

@@ -63,3 +63,11 @@ spec:
     backgroundConsolidation: true
     writeOnApprovalResolution: true
     writeOnRunCompletion: true
+
+  # agent-harness feature: optional Mem0 OSS ingestion engine for automatic long-term knowledge extraction.
+  mem0:
+    enabled: false
+    apiKeyEnv: MEM0_API_KEY
+    appId: agent-harness
+    stateStorePath: mem0-sync-state.json
+    maxMessagesPerRun: 200

package/dist/init-project.js

@@ -131,7 +131,7 @@ spec:
         kind: StoreBackend
 `;
 }
-function renderRuntimeMemoryYaml() {
+function renderRuntimeMemoryYaml(projectSlug) {
     return `apiVersion: agent-harness/v1alpha1
 kind: RuntimeMemory
 metadata:
@@ -156,6 +156,16 @@ spec:
       - scratchpad
       - transient_reasoning
       - intermediate_results
+  ingestion:
+    backgroundConsolidation: true
+    writeOnApprovalResolution: true
+    writeOnRunCompletion: true
+  mem0:
+    enabled: false
+    apiKeyEnv: MEM0_API_KEY
+    appId: ${projectSlug}
+    stateStorePath: mem0-sync-state.json
+    maxMessagesPerRun: 200
 `;
 }
 function renderToolsYaml(options) {
@@ -321,7 +331,7 @@ export async function initProject(projectRoot, projectName, options = {}) {
         ["config/runtime/workspace.yaml", renderWorkspaceYaml()],
         ["config/agent-context.md", renderAgentContext(resolved)],
         ["config/catalogs/models.yaml", renderModelsYaml(resolved)],
-        ["config/runtime/runtime-memory.yaml", renderRuntimeMemoryYaml()],
+        ["config/runtime/runtime-memory.yaml", renderRuntimeMemoryYaml(projectSlug)],
         ["config/catalogs/backends.yaml", renderBackendsYaml()],
         ["config/catalogs/tools.yaml", renderToolsYaml(resolved)],
         ["config/agents/research.yaml", renderResearchAgentYaml(resolved)],

package/dist/package-version.d.ts

@@ -1 +1 @@
-export declare const AGENT_HARNESS_VERSION = "0.0.126";
+export declare const AGENT_HARNESS_VERSION = "0.0.128";

package/dist/package-version.js

@@ -1 +1 @@
-export const AGENT_HARNESS_VERSION = "0.0.126";
+export const AGENT_HARNESS_VERSION = "0.0.128";

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

@@ -1,5 +1,6 @@
 import { AGENT_INTERRUPT_SENTINEL_PREFIX, RuntimeOperationTimeoutError } from "../../agent-runtime-adapter.js";
 import { renderRuntimeFailure, renderToolFailure } from "../../support/harness-support.js";
+import { getBindingPrimaryModel } from "../../support/compiled-binding.js";
 import { createContentBlocksItem, createToolResultKey, } from "../events/streaming.js";
 function normalizeStreamChunk(chunk) {
     if (typeof chunk === "string") {
@@ -27,12 +28,21 @@ function normalizeStreamChunk(chunk) {
     }
     return { kind: "content", content: chunk.content ?? "" };
 }
+function isOpenAICompatibleStreamingCompatibilityError(binding, error) {
+    const primaryModel = getBindingPrimaryModel(binding);
+    if (primaryModel?.provider !== "openai-compatible") {
+        return false;
+    }
+    const message = error instanceof Error ? error.message : String(error);
+    return message.toLowerCase().includes("received empty response from chat model call");
+}
 export async function* streamHarnessRun(options) {
     const priorHistoryPromise = Promise.resolve(options.isNewThread ? [] : undefined).then((historyHint) => historyHint ?? options.loadPriorHistory(options.threadId, options.runId));
     yield { type: "event", event: await options.runCreatedEventPromise };
     let releaseRunSlot = async () => undefined;
     let emitted = false;
     let streamActivityObserved = false;
+    let nonUpstreamStreamActivityObserved = false;
     try {
         const [priorHistory, acquiredReleaseRunSlot] = await Promise.all([
             priorHistoryPromise,
@@ -63,6 +73,7 @@ export async function* streamHarnessRun(options) {
                 };
                 continue;
             }
+            nonUpstreamStreamActivityObserved = true;
             if (normalizedChunk.kind === "interrupt") {
                 const checkpointRef = `checkpoints/${options.threadId}/${options.runId}/cp-1`;
                 const waitingEvent = await options.setRunStateAndEmit(options.threadId, options.runId, 6, "waiting_for_approval", {
@@ -148,7 +159,10 @@ export async function* streamHarnessRun(options) {
         };
     }
     catch (error) {
-        if (emitted || streamActivityObserved) {
+        const shouldRetryAfterStreamingCompatibilityError = streamActivityObserved &&
+            !nonUpstreamStreamActivityObserved &&
+            isOpenAICompatibleStreamingCompatibilityError(options.binding, error);
+        if ((emitted || streamActivityObserved) && !shouldRetryAfterStreamingCompatibilityError) {
             const runtimeFailure = renderRuntimeFailure(error);
             yield {
                 type: "event",

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

@@ -0,0 +1,42 @@
+import { 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";
+export type ResolvedMem0Config = {
+    enabled: true;
+    apiKeyEnv: string;
+    host?: string;
+    organizationName?: string;
+    projectName?: string;
+    organizationId?: string;
+    projectId?: string;
+    appId: string;
+    userIdPrefix?: string;
+    stateStorePath: string;
+    maxMessagesPerRun: number;
+    writeOnApprovalResolution: boolean;
+    writeOnRunCompletion: boolean;
+};
+type Mem0ClientLike = {
+    add(messages: Mem0Message[], options?: Record<string, unknown>): Promise<unknown>;
+};
+type Mem0ClientFactory = (config: ResolvedMem0Config) => Promise<Mem0ClientLike> | Mem0ClientLike;
+export declare function readMem0RuntimeConfig(runtimeMemory: Record<string, unknown> | undefined, workspaceRoot: string): ResolvedMem0Config | undefined;
+export declare class Mem0IngestionSync implements HarnessEventProjection {
+    private readonly persistence;
+    private readonly config;
+    private readonly runRoot;
+    private readonly stateStore;
+    private readonly clientFactory;
+    private readonly pending;
+    private syncChain;
+    private clientPromise;
+    readonly name = "mem0-ingestion-sync";
+    constructor(persistence: RuntimePersistence, config: ResolvedMem0Config, runRoot: string, stateStore?: StoreLike, clientFactory?: Mem0ClientFactory);
+    shouldHandle(event: HarnessEvent): boolean;
+    handleEvent(event: HarnessEvent): Promise<void>;
+    private getClient;
+    private syncRun;
+    close(): Promise<void>;
+}
+export {};

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

@@ -0,0 +1,181 @@
+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(["run.state.changed", "approval.resolved"]);
+function asRecord(value) {
+    return typeof value === "object" && value && !Array.isArray(value) ? value : undefined;
+}
+function asNonEmptyString(value) {
+    return typeof value === "string" && value.trim().length > 0 ? value.trim() : undefined;
+}
+function asPositiveInteger(value) {
+    return typeof value === "number" && Number.isInteger(value) && value > 0 ? value : undefined;
+}
+function asBoolean(value) {
+    return typeof value === "boolean" ? value : undefined;
+}
+function normalizeMessages(messages) {
+    const normalized = [];
+    for (const message of messages) {
+        const content = extractMessageText(message.content).trim();
+        if (!content) {
+            continue;
+        }
+        normalized.push({
+            role: message.role,
+            content,
+        });
+    }
+    return normalized;
+}
+function fingerprintMessages(messages) {
+    const hash = createHash("sha256");
+    for (const message of messages) {
+        hash.update(message.role);
+        hash.update("\n");
+        hash.update(message.createdAt);
+        hash.update("\n");
+        hash.update(extractMessageText(message.content));
+        hash.update("\n---\n");
+    }
+    return hash.digest("hex");
+}
+export function readMem0RuntimeConfig(runtimeMemory, workspaceRoot) {
+    if (runtimeMemory?.enabled !== true) {
+        return undefined;
+    }
+    const mem0 = asRecord(runtimeMemory.mem0);
+    if (!mem0 || mem0.enabled !== true) {
+        return undefined;
+    }
+    const ingestion = asRecord(runtimeMemory.ingestion);
+    const workspaceBaseName = path.basename(workspaceRoot) || "agent-harness";
+    return {
+        enabled: true,
+        apiKeyEnv: asNonEmptyString(mem0.apiKeyEnv) ?? "MEM0_API_KEY",
+        host: asNonEmptyString(mem0.host),
+        organizationName: asNonEmptyString(mem0.organizationName),
+        projectName: asNonEmptyString(mem0.projectName),
+        organizationId: asNonEmptyString(mem0.organizationId),
+        projectId: asNonEmptyString(mem0.projectId),
+        appId: asNonEmptyString(mem0.appId) ?? workspaceBaseName,
+        userIdPrefix: asNonEmptyString(mem0.userIdPrefix),
+        stateStorePath: asNonEmptyString(mem0.stateStorePath) ?? "mem0-sync-state.json",
+        maxMessagesPerRun: asPositiveInteger(mem0.maxMessagesPerRun) ?? 200,
+        writeOnApprovalResolution: asBoolean(mem0.writeOnApprovalResolution) ?? asBoolean(ingestion?.writeOnApprovalResolution) ?? true,
+        writeOnRunCompletion: asBoolean(mem0.writeOnRunCompletion) ?? asBoolean(ingestion?.writeOnRunCompletion) ?? true,
+    };
+}
+async function createDefaultMem0Client(config) {
+    const apiKey = process.env[config.apiKeyEnv];
+    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 } : {}),
+    });
+}
+export class Mem0IngestionSync {
+    persistence;
+    config;
+    runRoot;
+    stateStore;
+    clientFactory;
+    pending = new Set();
+    syncChain = Promise.resolve();
+    clientPromise = null;
+    name = "mem0-ingestion-sync";
+    constructor(persistence, config, runRoot, stateStore = new FileBackedStore(path.join(runRoot, config.stateStorePath)), clientFactory = createDefaultMem0Client) {
+        this.persistence = persistence;
+        this.config = config;
+        this.runRoot = runRoot;
+        this.stateStore = stateStore;
+        this.clientFactory = clientFactory;
+    }
+    shouldHandle(event) {
+        if (!MEM0_EVENT_TYPES.has(event.eventType)) {
+            return false;
+        }
+        if (event.eventType === "approval.resolved") {
+            return this.config.writeOnApprovalResolution;
+        }
+        if (event.eventType === "run.state.changed") {
+            return this.config.writeOnRunCompletion && event.payload.state === "completed";
+        }
+        return false;
+    }
+    async handleEvent(event) {
+        if (!this.shouldHandle(event)) {
+            return;
+        }
+        const trigger = event.eventType === "approval.resolved" ? "approval.resolved" : "run.completed";
+        const task = this.syncChain
+            .then(() => this.syncRun(event.threadId, event.runId, trigger))
+            .catch(() => {
+            // Fail open: memory ingestion must not break run execution.
+        });
+        this.syncChain = task
+            .catch(() => {
+            // Fail open: memory ingestion must not break run execution.
+        })
+            .finally(() => {
+            this.pending.delete(task);
+        });
+        this.pending.add(task);
+    }
+    async getClient() {
+        if (!this.clientPromise) {
+            this.clientPromise = Promise.resolve(this.clientFactory(this.config));
+        }
+        return this.clientPromise;
+    }
+    async syncRun(threadId, runId, trigger) {
+        const allMessages = await this.persistence.listThreadMessages(threadId, this.config.maxMessagesPerRun);
+        const runMessages = allMessages.filter((message) => message.runId === runId);
+        const normalized = normalizeMessages(runMessages);
+        if (normalized.length === 0) {
+            return;
+        }
+        const fingerprint = fingerprintMessages(runMessages);
+        const namespace = ["mem0", "threads", threadId, "runs"];
+        const existingCursor = await this.stateStore.get(namespace, runId);
+        const existing = existingCursor?.value;
+        if (existing?.fingerprint === fingerprint) {
+            return;
+        }
+        const [thread, run, client] = await Promise.all([
+            this.persistence.getSession(threadId),
+            this.persistence.getRun(runId),
+            this.getClient(),
+        ]);
+        await client.add(normalized, {
+            ...(this.config.userIdPrefix ? { user_id: `${this.config.userIdPrefix}${threadId}` } : {}),
+            run_id: runId,
+            agent_id: run?.agentId ?? thread?.agentId,
+            app_id: this.config.appId,
+            metadata: {
+                source: "agent-harness",
+                threadId,
+                runId,
+                agentId: run?.agentId ?? thread?.agentId,
+                trigger,
+            },
+        });
+        await this.stateStore.put(namespace, runId, {
+            fingerprint,
+            messageCount: normalized.length,
+            syncedAt: new Date().toISOString(),
+            trigger,
+        });
+    }
+    async close() {
+        await Promise.allSettled(Array.from(this.pending));
+    }
+}

package/dist/runtime/harness.d.ts

@@ -23,6 +23,8 @@ export declare class AgentHarnessRuntime {
     private readonly routingDefaultAgentId?;
     private readonly threadMemorySync;
     private readonly unregisterThreadMemorySync;
+    private readonly mem0IngestionSync;
+    private readonly unregisterMem0IngestionSync;
     private readonly resolvedRuntimeAdapterOptions;
     private readonly healthMonitor;
     private readonly recoveryConfig;

package/dist/runtime/harness.js

@@ -25,6 +25,7 @@ import { getBindingRuntimeExecutionMode, } from "./support/compiled-binding.js";
 import { bindingSupportsRunningReplay, getWorkspaceBinding, resolveWorkspaceAgentTools, } from "./harness/bindings.js";
 import { describeWorkspaceInventory, getAgentInventoryRecord, listAgentSkills as listWorkspaceAgentSkills, } from "./harness/system/inventory.js";
 import { createDefaultHealthSnapshot, isInventoryEnabled, isThreadMemorySyncEnabled, } from "./harness/runtime-defaults.js";
+import { Mem0IngestionSync, readMem0RuntimeConfig } from "./harness/system/mem0-ingestion-sync.js";
 import { resolveRuntimeAdapterOptions } from "./support/runtime-adapter-options.js";
 import { initializeHarnessRuntime, reclaimExpiredClaimedRuns as reclaimHarnessExpiredClaimedRuns, recoverStartupRuns as recoverHarnessStartupRuns, isStaleRunningRun as isHarnessStaleRunningRun, } from "./harness/run/startup-runtime.js";
 import { streamHarnessRun } from "./harness/run/stream-run.js";
@@ -56,6 +57,8 @@ export class AgentHarnessRuntime {
     routingDefaultAgentId;
     threadMemorySync;
     unregisterThreadMemorySync;
+    mem0IngestionSync;
+    unregisterMem0IngestionSync;
     resolvedRuntimeAdapterOptions;
     healthMonitor;
     recoveryConfig;
@@ -139,6 +142,15 @@ export class AgentHarnessRuntime {
             this.threadMemorySync = null;
             this.unregisterThreadMemorySync = () => { };
         }
+        const mem0RuntimeConfig = readMem0RuntimeConfig(this.defaultRuntimeEntryBinding?.harnessRuntime.runtimeMemory, this.workspace.workspaceRoot);
+        if (mem0RuntimeConfig) {
+            this.mem0IngestionSync = new Mem0IngestionSync(this.persistence, mem0RuntimeConfig, runRoot);
+            this.unregisterMem0IngestionSync = this.eventBus.registerProjection(this.mem0IngestionSync);
+        }
+        else {
+            this.mem0IngestionSync = null;
+            this.unregisterMem0IngestionSync = () => { };
+        }
         this.recoveryConfig = getRecoveryConfig(workspace.refs);
         this.concurrencyConfig = getConcurrencyConfig(workspace.refs);
         const healthConfig = readHealthMonitorConfig(workspace);
@@ -568,8 +580,10 @@ export class AgentHarnessRuntime {
         this.closed = true;
         await this.healthMonitor?.stop();
         this.unregisterThreadMemorySync();
+        this.unregisterMem0IngestionSync();
         await Promise.allSettled(Array.from(this.backgroundTasks));
         await this.threadMemorySync?.close();
+        await this.mem0IngestionSync?.close();
         this.initialized = false;
     }
     async stop() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@botbotgo/agent-harness",
-  "version": "0.0.127",
+  "version": "0.0.129",
   "description": "Workspace runtime for multi-agent applications",
   "type": "module",
   "packageManager": "npm@10.9.2",
@@ -46,9 +46,12 @@
     "@libsql/client": "^0.17.0",
     "@llamaindex/ollama": "^0.1.23",
     "@modelcontextprotocol/sdk": "^1.12.0",
+    "@qdrant/js-client-rest": "^1.13.0",
+    "better-sqlite3": "^12.8.0",
     "deepagents": "1.8.4",
     "langchain": "^1.2.36",
     "llamaindex": "^0.12.1",
+    "mem0ai": "^2.4.4",
     "mustache": "^4.2.0",
     "yaml": "^2.8.1",
     "zod": "^3.25.67"