@botbotgo/agent-harness 0.0.142 → 0.0.144

package/dist/contracts/runtime.d.ts

@@ -97,6 +97,20 @@ export type RuntimeSnapshot = {
     skills: RuntimeSnapshotSkill[];
     memory: string[];
 };
+export type MemoryCandidate = {
+    content: string;
+    summary?: string;
+    kind?: string;
+    scope?: string;
+    confidence?: number;
+    tags?: string[];
+    sourceType?: string;
+    sourceRef?: string;
+    observedAt?: string;
+    sensitivity?: string;
+    noStore?: boolean;
+    provenance?: Record<string, unknown>;
+};
 /**
  * Operator-facing projection of tool execution policy already compiled into a binding.
  * This summarizes existing timeout, retry, validation, and retry-safety hints without

package/dist/package-version.d.ts

@@ -1 +1 @@
-export declare const AGENT_HARNESS_VERSION = "0.0.141";
+export declare const AGENT_HARNESS_VERSION = "0.0.143";

package/dist/package-version.js

@@ -1 +1 @@
-export const AGENT_HARNESS_VERSION = "0.0.141";
+export const AGENT_HARNESS_VERSION = "0.0.143";

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

@@ -12,6 +12,7 @@ export declare function executeRuntimeInvocation(options: {
         context?: Record<string, unknown>;
         state?: Record<string, unknown>;
         files?: Record<string, unknown>;
+        memoryContext?: string;
     };
     resolveTools: (tools: CompiledTool[], binding?: CompiledAgentBinding) => unknown[];
     getToolNameMapping: (binding: CompiledAgentBinding) => ToolNameMapping;
@@ -19,6 +20,7 @@ export declare function executeRuntimeInvocation(options: {
         context?: Record<string, unknown>;
         state?: Record<string, unknown>;
         files?: Record<string, unknown>;
+        memoryContext?: string;
     }) => Promise<Map<string, ExecutableTool>>;
     callRuntimeWithToolParseRecovery: (request: unknown) => Promise<Record<string, unknown>>;
 }): Promise<RunResult>;

package/dist/runtime/adapter/flow/stream-runtime.d.ts

@@ -15,6 +15,7 @@ export declare function streamRuntimeExecution(options: {
         state?: Record<string, unknown>;
         files?: Record<string, unknown>;
         runId?: string;
+        memoryContext?: string;
     };
     primaryTools: CompiledTool[];
     toolNameMapping: ToolNameMapping;
@@ -33,6 +34,7 @@ export declare function streamRuntimeExecution(options: {
         context?: Record<string, unknown>;
         state?: Record<string, unknown>;
         files?: Record<string, unknown>;
+        memoryContext?: string;
     }) => Promise<{
         output: string;
         metadata?: Record<string, unknown>;

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

@@ -8,7 +8,7 @@ export async function* streamRuntimeExecution(options) {
     const request = buildInvocationRequest(options.binding, options.history, options.input, options.runtimeOptions);
     try {
         if (options.isLangChainBinding(options.binding) && options.canUseDirectModelStream && options.langChainStreamModel?.stream) {
-            const stream = await options.withTimeout(() => options.langChainStreamModel.stream(buildRawModelMessages(options.binding, options.getSystemPrompt(options.binding), options.history, options.input)), computeRemainingTimeoutMs(options.streamDeadlineAt, options.invokeTimeoutMs), "model stream start", "stream");
+            const stream = await options.withTimeout(() => options.langChainStreamModel.stream(buildRawModelMessages(options.binding, options.getSystemPrompt(options.binding), options.history, options.input, options.runtimeOptions.memoryContext)), computeRemainingTimeoutMs(options.streamDeadlineAt, options.invokeTimeoutMs), "model stream start", "stream");
             let emitted = false;
             const projected = projectTextStreamChunks(options.iterateWithTimeout(stream, options.streamIdleTimeoutMs, "model stream", options.streamDeadlineAt, options.invokeTimeoutMs));
             let nextChunk = await projected.next();

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

@@ -1,8 +1,9 @@
-import type { RunResult } from "../../contracts/types.js";
+import type { MemoryCandidate, RunResult } from "../../contracts/types.js";
 export type ExecutedToolResult = {
     toolName: string;
     output: unknown;
     isError?: boolean;
+    memoryCandidates?: MemoryCandidate[];
 };
 export declare function finalizeInvocationResult(params: {
     bindingAgentId: string;

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

@@ -18,6 +18,7 @@ export function finalizeInvocationResult(params) {
     const structuredResponse = result.structuredResponse;
     const files = asRecord(result.files);
     const stateSnapshot = buildStateSnapshot(result);
+    const memoryCandidates = executedToolResults.flatMap((toolResult) => toolResult.memoryCandidates ?? []);
     return {
         threadId,
         runId,
@@ -31,6 +32,7 @@ export function finalizeInvocationResult(params) {
         ...(structuredResponse !== undefined ? { structuredResponse } : {}),
         metadata: {
             ...(executedToolResults.length > 0 ? { executedToolResults } : {}),
+            ...(memoryCandidates.length > 0 ? { memoryCandidates } : {}),
             ...(structuredResponse !== undefined ? { structuredResponse } : {}),
             ...(outputContent !== undefined ? { outputContent } : {}),
             ...(contentBlocks.length > 0 ? { contentBlocks } : {}),

package/dist/runtime/adapter/local-tool-invocation.js

@@ -2,6 +2,7 @@ import { ToolMessage } from "@langchain/core/messages";
 import { createModelFacingToolNameLookupCandidates, resolveModelFacingToolName } from "./tool/tool-name-mapping.js";
 import { canReplayToolCallsLocally } from "./tool/tool-replay.js";
 import { extractToolCallsFromResult, normalizeToolArgsForSchema, stringifyToolOutput } from "./tool/tool-arguments.js";
+import { extractMemoryCandidatesFromToolOutput } from "../harness/system/runtime-memory-candidates.js";
 export async function runLocalToolInvocationLoop({ binding, request, primaryTools, toolNameMapping, executableTools, builtinExecutableTools, callRuntimeWithToolParseRecovery, }) {
     const executedToolResults = [];
     let activeRequest = request;
@@ -9,6 +10,14 @@ export async function runLocalToolInvocationLoop({ binding, request, primaryTool
     const maxToolIterations = 8;
     let pendingResult;
     let result;
+    const toolCatalog = new Map();
+    for (const tool of primaryTools) {
+        toolCatalog.set(tool.name, tool);
+        const modelFacingName = toolNameMapping.originalToModelFacing.get(tool.name);
+        if (modelFacingName) {
+            toolCatalog.set(modelFacingName, tool);
+        }
+    }
     for (let iteration = 0; iteration < maxToolIterations; iteration += 1) {
         result = pendingResult ?? await callRuntimeWithToolParseRecovery(activeRequest);
         pendingResult = undefined;
@@ -39,11 +48,14 @@ export async function runLocalToolInvocationLoop({ binding, request, primaryTool
             if (!activeExecutable) {
                 throw new Error(`Tool ${toolCall.name} is not configured for this agent.`);
             }
+            const compiledTool = toolCatalog.get(toolCall.name) ?? toolCatalog.get(resolvedToolName);
             const normalizedArgs = normalizeToolArgsForSchema(toolCall.args, activeExecutable.schema);
             const toolResult = await activeExecutable.invoke(normalizedArgs);
+            const memoryCandidates = compiledTool ? extractMemoryCandidatesFromToolOutput(compiledTool, toolResult) : [];
             executedToolResults.push({
                 toolName: activeExecutable.name,
                 output: toolResult,
+                ...(memoryCandidates.length > 0 ? { memoryCandidates } : {}),
             });
             nextMessages.push(new ToolMessage({
                 name: activeExecutable.name,

package/dist/runtime/adapter/model/invocation-request.d.ts

@@ -7,4 +7,5 @@ export declare function buildSlashCommandSkillInstruction(binding: CompiledAgent
 export declare function buildInvocationRequest(binding: CompiledAgentBinding, history: TranscriptMessage[], input: MessageContent, options?: {
     state?: Record<string, unknown>;
     files?: Record<string, unknown>;
+    memoryContext?: string;
 }): Record<string, unknown>;

package/dist/runtime/adapter/model/invocation-request.js

@@ -37,11 +37,21 @@ export function buildSlashCommandSkillInstruction(binding, input) {
 export function buildInvocationRequest(binding, history, input, options = {}) {
     const userInvocableInstruction = buildSlashCommandSkillInstruction(binding, input);
     const messages = buildAgentMessages(history, input);
+    const memoryInstruction = typeof options.memoryContext === "string" && options.memoryContext.trim().length > 0
+        ? [
+            "Relevant durable memory was retrieved for this run.",
+            "Use it when it is still applicable, but prefer fresher direct evidence if there is any conflict.",
+            "",
+            options.memoryContext.trim(),
+        ].join("\n")
+        : undefined;
     return {
         ...(options.state ?? {}),
         ...(options.files ? { files: options.files } : {}),
-        messages: userInvocableInstruction
-            ? [{ role: "system", content: userInvocableInstruction }, ...messages]
-            : messages,
+        messages: [
+            ...(memoryInstruction ? [{ role: "system", content: memoryInstruction }] : []),
+            ...(userInvocableInstruction ? [{ role: "system", content: userInvocableInstruction }] : []),
+            ...messages,
+        ],
     };
 }

package/dist/runtime/adapter/model/message-assembly.d.ts

@@ -1,6 +1,6 @@
 import type { CompiledAgentBinding, MessageContent, TranscriptMessage } from "../../../contracts/types.js";
 export declare function buildStateSnapshot(result: Record<string, unknown>): Record<string, unknown> | undefined;
-export declare function buildRawModelMessages(binding: CompiledAgentBinding, systemPrompt: string | undefined, history: TranscriptMessage[], input: MessageContent): Array<{
+export declare function buildRawModelMessages(binding: CompiledAgentBinding, systemPrompt: string | undefined, history: TranscriptMessage[], input: MessageContent, memoryContext?: string): Array<{
     role: string;
     content: MessageContent;
 }>;

package/dist/runtime/adapter/model/message-assembly.js

@@ -7,11 +7,22 @@ export function buildStateSnapshot(result) {
     delete snapshot.files;
     return Object.keys(snapshot).length > 0 ? snapshot : undefined;
 }
-export function buildRawModelMessages(binding, systemPrompt, history, input) {
+export function buildRawModelMessages(binding, systemPrompt, history, input, memoryContext) {
     const messages = [];
     if (systemPrompt) {
         messages.push({ role: "system", content: systemPrompt });
     }
+    if (memoryContext?.trim()) {
+        messages.push({
+            role: "system",
+            content: [
+                "Relevant durable memory was retrieved for this run.",
+                "Use it when it still applies, but prefer fresher direct evidence if there is any conflict.",
+                "",
+                memoryContext.trim(),
+            ].join("\n"),
+        });
+    }
     const userInvocableInstruction = buildSlashCommandSkillInstruction(binding, input);
     if (userInvocableInstruction) {
         messages.push({ role: "system", content: userInvocableInstruction });

package/dist/runtime/agent-runtime-adapter.d.ts

@@ -80,12 +80,14 @@ export declare class AgentRuntimeAdapter {
         context?: Record<string, unknown>;
         state?: Record<string, unknown>;
         files?: Record<string, unknown>;
+        memoryContext?: string;
     }): Promise<RunResult>;
     stream(binding: CompiledAgentBinding, input: MessageContent, threadId: string, history?: TranscriptMessage[], options?: {
         context?: Record<string, unknown>;
         state?: Record<string, unknown>;
         files?: Record<string, unknown>;
         runId?: string;
+        memoryContext?: string;
     }): AsyncGenerator<RuntimeStreamChunk | string>;
 }
 export { AgentRuntimeAdapter as RuntimeAdapter, AGENT_INTERRUPT_SENTINEL_PREFIX, AGENT_INTERRUPT_SENTINEL_PREFIX as INTERRUPT_SENTINEL_PREFIX, RuntimeOperationTimeoutError, };

package/dist/runtime/harness/run/stream-run.d.ts

@@ -15,6 +15,7 @@ type StreamRunOptions = {
         context?: Record<string, unknown>;
         state?: Record<string, unknown>;
         files?: Record<string, unknown>;
+        memoryContext?: string;
     };
     threadId: string;
     runId: string;
@@ -28,6 +29,7 @@ type StreamRunOptions = {
         state?: Record<string, unknown>;
         files?: Record<string, unknown>;
         runId: string;
+        memoryContext?: string;
     }) => AsyncIterable<RuntimeStreamChunk>;
     invokeWithHistory: (binding: CompiledAgentBinding, input: MessageContent, threadId: string, runId: string) => Promise<RunResult>;
     emit: (threadId: string, runId: string, sequence: number, eventType: string, payload: Record<string, unknown>) => Promise<HarnessEvent>;

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

@@ -60,6 +60,7 @@ export async function* streamHarnessRun(options) {
             state: options.invocation.state,
             files: options.invocation.files,
             runId: options.runId,
+            memoryContext: options.invocation.memoryContext,
         })) {
             if (!rawChunk) {
                 continue;

package/dist/runtime/harness/system/runtime-memory-candidates.d.ts

@@ -0,0 +1,3 @@
+import type { CompiledTool, MemoryCandidate } from "../../../contracts/types.js";
+export declare function extractMemoryCandidatesFromToolOutput(tool: CompiledTool, output: unknown): MemoryCandidate[];
+export declare function renderMemoryCandidatesMarkdown(title: string, candidates: MemoryCandidate[]): string;

package/dist/runtime/harness/system/runtime-memory-candidates.js

@@ -0,0 +1,110 @@
+function asRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value) ? value : undefined;
+}
+function asString(value) {
+    return typeof value === "string" && value.trim().length > 0 ? value.trim() : undefined;
+}
+function asNumber(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+function asStringArray(value) {
+    if (!Array.isArray(value)) {
+        return undefined;
+    }
+    const items = value
+        .filter((item) => typeof item === "string" && item.trim().length > 0)
+        .map((item) => item.trim());
+    return items.length > 0 ? items : undefined;
+}
+function stringifyCandidateContent(output) {
+    if (typeof output === "string") {
+        return output.trim();
+    }
+    if (typeof output === "number" || typeof output === "boolean") {
+        return String(output);
+    }
+    if (typeof output === "object" && output !== null) {
+        try {
+            return JSON.stringify(output, null, 2);
+        }
+        catch {
+            return "";
+        }
+    }
+    return "";
+}
+function normalizeCandidate(value, fallback) {
+    const record = asRecord(value);
+    if (!record) {
+        return null;
+    }
+    const content = asString(record.content);
+    if (!content) {
+        return null;
+    }
+    return {
+        content,
+        ...(asString(record.summary) ? { summary: asString(record.summary) } : {}),
+        ...(asString(record.kind) ?? fallback.kind ? { kind: asString(record.kind) ?? fallback.kind } : {}),
+        ...(asString(record.scope) ?? fallback.scope ? { scope: asString(record.scope) ?? fallback.scope } : {}),
+        ...(asNumber(record.confidence) !== undefined ? { confidence: asNumber(record.confidence) } : {}),
+        ...(asStringArray(record.tags) ?? fallback.tags ? { tags: asStringArray(record.tags) ?? fallback.tags } : {}),
+        ...(asString(record.sourceType) ?? fallback.sourceType ? { sourceType: asString(record.sourceType) ?? fallback.sourceType } : {}),
+        ...(asString(record.sourceRef) ? { sourceRef: asString(record.sourceRef) } : {}),
+        ...(asString(record.observedAt) ? { observedAt: asString(record.observedAt) } : {}),
+        ...(asString(record.sensitivity) ? { sensitivity: asString(record.sensitivity) } : {}),
+        ...(typeof record.noStore === "boolean" ? { noStore: record.noStore } : {}),
+        ...(asRecord(record.provenance) ? { provenance: asRecord(record.provenance) } : {}),
+    };
+}
+export function extractMemoryCandidatesFromToolOutput(tool, output) {
+    const memoryConfig = asRecord(tool.config?.memory);
+    if (memoryConfig?.enabled !== true) {
+        return [];
+    }
+    const fallback = {
+        sourceType: "tool-output",
+        kind: asString(memoryConfig.kind),
+        scope: asString(memoryConfig.scope) ?? "thread",
+        tags: asStringArray(memoryConfig.tags),
+    };
+    const explicitCandidates = asRecord(output)?.memoryCandidates;
+    if (Array.isArray(explicitCandidates)) {
+        const maxCandidates = asNumber(memoryConfig.maxCandidates) ?? explicitCandidates.length;
+        return explicitCandidates
+            .map((candidate) => normalizeCandidate(candidate, fallback))
+            .filter((candidate) => Boolean(candidate))
+            .slice(0, maxCandidates);
+    }
+    const content = stringifyCandidateContent(output);
+    if (!content) {
+        return [];
+    }
+    return [{
+            content,
+            ...(fallback.kind ? { kind: fallback.kind } : {}),
+            ...(fallback.scope ? { scope: fallback.scope } : {}),
+            ...(fallback.tags ? { tags: fallback.tags } : {}),
+            sourceType: fallback.sourceType,
+        }];
+}
+export function renderMemoryCandidatesMarkdown(title, candidates) {
+    const lines = [`# ${title}`, ""];
+    if (candidates.length === 0) {
+        lines.push("(none)", "");
+        return lines.join("\n");
+    }
+    for (const candidate of candidates) {
+        lines.push(`## ${(candidate.summary ?? candidate.content).split("\n")[0].slice(0, 120)}`);
+        lines.push(`- kind: ${candidate.kind ?? "summary"}`);
+        lines.push(`- scope: ${candidate.scope ?? "thread"}`);
+        lines.push(`- source_type: ${candidate.sourceType ?? "tool-output"}`);
+        if (candidate.tags && candidate.tags.length > 0) {
+            lines.push(`- tags: ${candidate.tags.join(", ")}`);
+        }
+        lines.push("");
+        lines.push(candidate.summary ?? candidate.content);
+        lines.push("");
+    }
+    return lines.join("\n");
+}

package/dist/runtime/harness.d.ts

@@ -90,6 +90,10 @@ export declare class AgentHarnessRuntime {
     private getRunCancellation;
     private finalizeCancelledRun;
     private invokeWithHistory;
+    private getWorkspaceMemoryNamespace;
+    private buildRuntimeMemoryContext;
+    private persistRuntimeMemoryCandidates;
+    private appendMemoryDigest;
     private resolvePersistedRunPriority;
     private enqueuePendingRunSlot;
     private executeQueuedRun;

package/dist/runtime/harness.js

@@ -1,3 +1,4 @@
+import path from "node:path";
 import { SqlitePersistence } from "../persistence/sqlite-store.js";
 import { createPersistentId } from "../utils/id.js";
 import { AgentRuntimeAdapter } from "./agent-runtime-adapter.js";
@@ -28,6 +29,7 @@ import { bindingSupportsRunningReplay, getWorkspaceBinding, resolveWorkspaceAgen
 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 { renderMemoryCandidatesMarkdown } from "./harness/system/runtime-memory-candidates.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";
@@ -349,9 +351,14 @@ export class AgentHarnessRuntime {
     }
     async invokeWithHistory(binding, input, threadId, runId, resumePayload, priorHistory, options = {}) {
         const history = priorHistory ?? await this.loadPriorHistory(threadId, runId);
+        const memoryContext = options.memoryContext ?? await this.buildRuntimeMemoryContext(binding, threadId);
         const startedAt = Date.now();
         try {
-            const result = await this.runtimeAdapter.invoke(binding, input, threadId, runId, resumePayload, history, options);
+            const result = await this.runtimeAdapter.invoke(binding, input, threadId, runId, resumePayload, history, {
+                ...options,
+                ...(memoryContext ? { memoryContext } : {}),
+            });
+            await this.persistRuntimeMemoryCandidates(binding, threadId, runId, result.metadata?.memoryCandidates);
             this.recordLlmSuccess(startedAt);
             return result;
         }
@@ -360,6 +367,74 @@ export class AgentHarnessRuntime {
             throw error;
         }
     }
+    getWorkspaceMemoryNamespace(binding) {
+        const workspaceRoot = binding.harnessRuntime.workspaceRoot ?? this.workspace.workspaceRoot;
+        return ["memories", "workspaces", path.basename(workspaceRoot) || "default"];
+    }
+    async buildRuntimeMemoryContext(binding, threadId) {
+        const docs = await Promise.all([
+            this.runtimeMemoryStore.get(["memories", "threads", threadId], "durable-summary.md"),
+            this.runtimeMemoryStore.get(["memories", "threads", threadId], "tool-memory.md"),
+            this.runtimeMemoryStore.get(this.getWorkspaceMemoryNamespace(binding), "tool-memory.md"),
+        ]);
+        const parts = docs
+            .map((doc) => doc?.value)
+            .map((value) => (typeof value?.content === "string" ? value.content.trim() : ""))
+            .filter((value) => value.length > 0);
+        if (parts.length === 0) {
+            return undefined;
+        }
+        return parts.join("\n\n");
+    }
+    async persistRuntimeMemoryCandidates(binding, threadId, runId, value) {
+        if (!Array.isArray(value) || value.length === 0) {
+            return;
+        }
+        const candidates = value
+            .filter((candidate) => typeof candidate === "object" && candidate !== null)
+            .filter((candidate) => candidate.noStore !== true && typeof candidate.content === "string" && candidate.content.trim().length > 0);
+        if (candidates.length === 0) {
+            return;
+        }
+        const threadCandidates = candidates.filter((candidate) => (candidate.scope ?? "thread") === "thread");
+        const workspaceCandidates = candidates.filter((candidate) => (candidate.scope ?? "thread") === "workspace");
+        const agentCandidates = candidates.filter((candidate) => (candidate.scope ?? "thread") === "agent");
+        await this.runtimeMemoryStore.put(["memories", "candidates", threadId], `${runId}.json`, {
+            runId,
+            threadId,
+            storedAt: new Date().toISOString(),
+            candidates,
+        });
+        const writes = [];
+        if (threadCandidates.length > 0) {
+            writes.push(this.appendMemoryDigest(["memories", "threads", threadId], "tool-memory.md", threadCandidates, 12, "Thread Tool Memory"));
+        }
+        if (workspaceCandidates.length > 0) {
+            writes.push(this.appendMemoryDigest(this.getWorkspaceMemoryNamespace(binding), "tool-memory.md", workspaceCandidates, 20, "Workspace Tool Memory"));
+        }
+        if (agentCandidates.length > 0) {
+            writes.push(this.appendMemoryDigest(["memories", "agents", binding.agent.id], "tool-memory.md", agentCandidates, 20, "Agent Tool Memory"));
+        }
+        await Promise.all(writes);
+    }
+    async appendMemoryDigest(namespace, key, candidates, maxEntries, title) {
+        const existing = await this.runtimeMemoryStore.get(namespace, key);
+        const existingItems = Array.isArray(existing?.value?.items)
+            ? ((existing?.value).items ?? [])
+            : [];
+        const merged = [...existingItems];
+        for (const candidate of candidates) {
+            if (merged.some((entry) => entry.content === candidate.content && (entry.scope ?? "thread") === (candidate.scope ?? "thread"))) {
+                continue;
+            }
+            merged.push(candidate);
+        }
+        const recent = merged.slice(-maxEntries);
+        await this.runtimeMemoryStore.put(namespace, key, {
+            content: `${renderMemoryCandidatesMarkdown(title, recent)}\n`,
+            items: recent,
+        });
+    }
     async resolvePersistedRunPriority(threadId, runId) {
         const persisted = await this.persistence.getRunRequest(threadId, runId);
         return normalizeRunPriority(persisted?.priority);
@@ -514,7 +589,10 @@ export class AgentHarnessRuntime {
         const stream = streamHarnessRun({
             binding,
             input: options.input,
-            invocation,
+            invocation: {
+                ...invocation,
+                memoryContext: await this.buildRuntimeMemoryContext(binding, threadId),
+            },
             threadId,
             runId,
             selectedAgentId,

package/dist/tool-modules.d.ts

@@ -6,6 +6,13 @@ export type LoadedToolModule = {
     schema: ReturnType<typeof normalizeToolSchema>;
     description: string;
     retryable?: boolean;
+    memory?: {
+        enabled: boolean;
+        kind?: string;
+        scope?: string;
+        maxCandidates?: number;
+        tags?: string[];
+    };
 };
 export type LoadedSkillModule = {
     name: string;

package/dist/tool-modules.js

@@ -22,6 +22,7 @@ function loadToolObjectDefinition(imported, exportName) {
         schema: normalizeToolSchema(definition.schema),
         description: definition.description.trim(),
         retryable: definition.retryable === true,
+        ...(definition.memory ? { memory: { ...definition.memory } } : {}),
     };
 }
 export function isSupportedToolModulePath(filePath) {

package/dist/tools.d.ts

@@ -6,6 +6,13 @@ export type ToolDefinitionObject = {
     description: string;
     schema: SchemaInput;
     retryable?: boolean;
+    memory?: {
+        enabled: boolean;
+        kind?: string;
+        scope?: string;
+        maxCandidates?: number;
+        tags?: string[];
+    };
     invoke: (input: unknown, context?: Record<string, unknown>) => Promise<unknown> | unknown;
     [TOOL_DEFINITION_MARKER]: true;
 };
@@ -17,6 +24,13 @@ export declare function tool(definition: {
     description: string;
     schema: SchemaInput;
     retryable?: boolean;
+    memory?: {
+        enabled: boolean;
+        kind?: string;
+        scope?: string;
+        maxCandidates?: number;
+        tags?: string[];
+    };
     invoke: (input: unknown, context?: Record<string, unknown>) => Promise<unknown> | unknown;
 }): ToolDefinitionObject;
 export {};

package/dist/workspace/object-loader.js

@@ -762,6 +762,7 @@ export async function readToolModuleItems(root) {
                     description: definition.description,
                     implementationName: definition.implementationName,
                     ...(definition.retryable !== undefined ? { retryable: definition.retryable } : {}),
+                    ...(definition.memory ? { config: { memory: definition.memory } } : {}),
                 },
                 sourcePath: filePath,
             });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@botbotgo/agent-harness",
-  "version": "0.0.142",
+  "version": "0.0.144",
   "description": "Workspace runtime for multi-agent applications",
   "type": "module",
   "packageManager": "npm@10.9.2",