@botbotgo/agent-harness 0.0.153 → 0.0.154

package/README.md

@@ -118,7 +118,7 @@ That means:
 
 The runtime provides:
 
-- `createAgentHarness(workspaceRoot)`, `run(...)`, `resolveApproval(...)`, `subscribe(...)`, inspection methods, and `stop(...)`
+- `createAgentHarness(workspaceRoot)`, `run(...)`, `memorize(...)`, `recall(...)`, `resolveApproval(...)`, `subscribe(...)`, inspection methods, and `stop(...)`
 - YAML-defined workspace assembly for routing, models, tools, stores, backends, MCP, recovery, and maintenance
 - backend-adapted execution with current LangChain v1 and DeepAgents adapters
 - local `resources/tools/` `tool({...})` modules and `resources/skills/` discovery
@@ -389,6 +389,36 @@ const result = await run(
 
 Use `normalizeUserChatInput(...)` when a product already has chat-style user messages and wants to project one user turn onto the stable `run(..., { input, invocation })` surface without introducing a separate harness-owned chat API.
 
+### Store And Recall Durable Runtime Memory
+
+```ts
+import { memorize, recall } from "@botbotgo/agent-harness";
+
+await memorize(runtime, {
+  threadId: "thread-123",
+  records: [
+    {
+      content: "The release checklist requires a smoke test before publish.",
+      summary: "Run a smoke test before publish",
+      scope: "workspace",
+      kind: "procedural",
+      sourceRef: "docs/release-checklist.md",
+    },
+  ],
+});
+
+const recalled = await recall(runtime, {
+  query: "What does the release checklist require?",
+  scopes: ["workspace"],
+});
+```
+
+Use `memorize(...)` and `recall(...)` when an application needs a stable public runtime memory surface without importing internal `runtime/harness/system/*` modules.
+
+- `memorize(...)` returns stable `MemoryRecord` and `MemoryDecision` results while leaving merge, review, archive, and storage layout runtime-managed
+- `recall(...)` returns ranked `MemoryRecord` items filtered by runtime memory scope and kind
+- app-specific knowledge taxonomy, review UI, and admin surfaces still belong in the application layer
+
 ### Let The Runtime Route
 
 ```ts

package/README.zh.md

@@ -118,7 +118,7 @@ AI 让 agent 逻辑、工具调用和工作流代码更容易生成，真正更
 
 运行时提供：
 
-- `createAgentHarness(workspaceRoot)`、`run(...)`、`resolveApproval(...)`、`subscribe(...)`、各类查询方法，以及 `stop(...)`
+- `createAgentHarness(workspaceRoot)`、`run(...)`、`memorize(...)`、`recall(...)`、`resolveApproval(...)`、`subscribe(...)`、各类查询方法，以及 `stop(...)`
 - 以 YAML 描述的工作区装配：路由、模型、工具、存储、后端、MCP、恢复与维护等
 - 通过适配器对接当前的 LangChain v1 与 DeepAgents 执行
 - 本地 `resources/tools/` 中 `tool({...})` 工具模块与 `resources/skills/` 的发现
@@ -360,6 +360,36 @@ const result = await run(runtime, {
 - `invocation.inputs`：结构化运行时输入
 - `invocation.attachments`：当前后端可解释的类附件负载
 
+### 写入与召回 durable runtime memory
+
+```ts
+import { memorize, recall } from "@botbotgo/agent-harness";
+
+await memorize(runtime, {
+  threadId: "thread-123",
+  records: [
+    {
+      content: "The release checklist requires a smoke test before publish.",
+      summary: "Run a smoke test before publish",
+      scope: "workspace",
+      kind: "procedural",
+      sourceRef: "docs/release-checklist.md",
+    },
+  ],
+});
+
+const recalled = await recall(runtime, {
+  query: "What does the release checklist require?",
+  scopes: ["workspace"],
+});
+```
+
+当应用需要稳定的公开 runtime memory 接口，而不想依赖内部 `runtime/harness/system/*` 模块时，使用 `memorize(...)` 与 `recall(...)`。
+
+- `memorize(...)` 返回稳定的 `MemoryRecord` 与 `MemoryDecision` 结果，而 merge、review、archive 与存储布局仍由 runtime 内部托管
+- `recall(...)` 返回按相关性排序、并按 scope / kind 过滤后的 `MemoryRecord`
+- 业务知识分类、review UI 与管理后台仍应留在应用层
+
 ### 由运行时路由
 
 ```ts

package/dist/api.d.ts

@@ -1,10 +1,11 @@
-import type { CancelOptions, InvocationEnvelope, MessageContent, RequestRecord, RequestSummary, ResumeOptions, RunDecisionOptions, RunResult, RunStartOptions, RuntimeHealthSnapshot, RuntimeAdapterOptions, SessionRecord, SessionSummary, WorkspaceLoadOptions } from "./contracts/types.js";
+import type { CancelOptions, InvocationEnvelope, MemorizeInput, MemorizeResult, MessageContent, RecallInput, RecallResult, RequestRecord, RequestSummary, ResumeOptions, RunDecisionOptions, RunResult, RunStartOptions, RuntimeHealthSnapshot, RuntimeAdapterOptions, SessionRecord, SessionSummary, WorkspaceLoadOptions } from "./contracts/types.js";
 import { AgentHarnessRuntime } from "./runtime/harness.js";
 import type { InventoryAgentRecord, InventorySkillRecord } from "./runtime/harness/system/inventory.js";
 import type { RequirementAssessmentOptions } from "./runtime/harness/system/skill-requirements.js";
 import type { ToolMcpServerOptions } from "./mcp.js";
 export { AgentHarnessRuntime } from "./runtime/harness.js";
 export { createUpstreamTimelineReducer } from "./upstream-events.js";
+export type { MemoryDecision, MemoryKind, MemoryRecord, MemoryScope, MemorizeInput, MemorizeResult, RecallInput, RecallResult, } from "./contracts/types.js";
 type PublicApprovalRecord = {
     approvalId: string;
     pendingActionId: string;
@@ -54,6 +55,8 @@ export declare function createAgentHarness(): Promise<AgentHarnessRuntime>;
 export declare function createAgentHarness(workspaceRoot: string, options?: CreateAgentHarnessOptions): Promise<AgentHarnessRuntime>;
 export declare function normalizeUserChatInput(input: UserChatInput, options?: NormalizeUserChatInputOptions): Pick<RunStartOptions, "input" | "invocation">;
 export declare function run(runtime: AgentHarnessRuntime, options: PublicRunOptions): Promise<PublicRunResult>;
+export declare function memorize(runtime: AgentHarnessRuntime, input: MemorizeInput): Promise<MemorizeResult>;
+export declare function recall(runtime: AgentHarnessRuntime, input: RecallInput): Promise<RecallResult>;
 export declare function subscribe(runtime: AgentHarnessRuntime, listener: Parameters<AgentHarnessRuntime["subscribe"]>[0]): () => void;
 export declare function listSessions(runtime: AgentHarnessRuntime, filter?: Parameters<AgentHarnessRuntime["listThreads"]>[0]): Promise<SessionSummary[]>;
 export declare function listRequests(runtime: AgentHarnessRuntime, filter?: {

package/dist/api.js

@@ -128,6 +128,12 @@ export function normalizeUserChatInput(input, options = {}) {
 export async function run(runtime, options) {
     return toPublicRunResult(await runtime.run(toInternalRunOptions(options)));
 }
+export async function memorize(runtime, input) {
+    return runtime.memorize(input);
+}
+export async function recall(runtime, input) {
+    return runtime.recall(input);
+}
 export function subscribe(runtime, listener) {
     return runtime.subscribe(listener);
 }

package/dist/contracts/runtime.d.ts

@@ -118,13 +118,14 @@ export type MemoryCandidate = {
     noStore?: boolean;
     provenance?: Record<string, unknown>;
 };
+export type MemoryKind = "semantic" | "episodic" | "procedural";
 export type MemoryScope = "thread" | "agent" | "workspace" | "user" | "project";
 export type MemoryRecordStatus = "active" | "stale" | "conflicted" | "archived" | "pending_review";
 export type MemoryDecisionAction = "reject" | "store" | "merge" | "refresh" | "supersede" | "archive" | "review";
 export type MemoryRecord = {
     id: string;
     canonicalKey: string;
-    kind: "semantic" | "episodic" | "procedural";
+    kind: MemoryKind;
     scope: MemoryScope;
     content: string;
     summary: string;
@@ -152,6 +153,48 @@ export type MemoryDecision = {
     maintenance?: "none" | "dedupe" | "merge" | "review";
     reviewRequired?: boolean;
 };
+export type MemorizeInputRecord = {
+    content: string;
+    summary?: string;
+    kind?: MemoryKind;
+    scope?: MemoryScope;
+    confidence?: number;
+    tags?: string[];
+    sourceType?: string;
+    sourceRef?: string;
+    observedAt?: string;
+    sensitivity?: string;
+    provenance?: Record<string, unknown>;
+    noStore?: boolean;
+};
+export type MemorizeInput = {
+    records: MemorizeInputRecord[];
+    threadId?: string;
+    runId?: string;
+    agentId?: string;
+    userId?: string;
+    projectId?: string;
+    recordedAt?: string;
+};
+export type MemorizeResult = {
+    records: MemoryRecord[];
+    decisions: MemoryDecision[];
+};
+export type RecallInput = {
+    query: string;
+    scopes?: MemoryScope[];
+    kinds?: MemoryKind[];
+    topK?: number;
+    includeStale?: boolean;
+    threadId?: string;
+    agentId?: string;
+    workspaceId?: string;
+    userId?: string;
+    projectId?: string;
+};
+export type RecallResult = {
+    items: MemoryRecord[];
+};
 /**
  * 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/index.d.ts

@@ -1,5 +1,5 @@
-export { AgentHarnessRuntime, cancelRun, createAgentHarness, createUpstreamTimelineReducer, createToolMcpServer, deleteSession, describeInventory, getAgent, getApproval, getRequest, getHealth, getSession, listAgentSkills, listApprovals, listRequests, listSessions, normalizeUserChatInput, resolveApproval, run, serveToolsOverStdio, subscribe, stop, } from "./api.js";
-export type { NormalizeUserChatInputOptions, UserChatInput, UserChatMessage } from "./api.js";
+export { AgentHarnessRuntime, cancelRun, createAgentHarness, createUpstreamTimelineReducer, createToolMcpServer, deleteSession, describeInventory, getAgent, getApproval, getRequest, getHealth, getSession, listAgentSkills, listApprovals, listRequests, listSessions, memorize, normalizeUserChatInput, recall, resolveApproval, run, serveToolsOverStdio, subscribe, stop, } from "./api.js";
+export type { MemoryDecision, MemoryKind, MemoryRecord, MemoryScope, MemorizeInput, MemorizeResult, NormalizeUserChatInputOptions, RecallInput, RecallResult, UserChatInput, UserChatMessage, } from "./api.js";
 export type { ToolMcpServerOptions } from "./mcp.js";
 export { tool } from "./tools.js";
 export type { UpstreamTimelineProjection, UpstreamTimelineReducer } from "./upstream-events.js";

package/dist/index.js

@@ -1,2 +1,2 @@
-export { AgentHarnessRuntime, cancelRun, createAgentHarness, createUpstreamTimelineReducer, createToolMcpServer, deleteSession, describeInventory, getAgent, getApproval, getRequest, getHealth, getSession, listAgentSkills, listApprovals, listRequests, listSessions, normalizeUserChatInput, resolveApproval, run, serveToolsOverStdio, subscribe, stop, } from "./api.js";
+export { AgentHarnessRuntime, cancelRun, createAgentHarness, createUpstreamTimelineReducer, createToolMcpServer, deleteSession, describeInventory, getAgent, getApproval, getRequest, getHealth, getSession, listAgentSkills, listApprovals, listRequests, listSessions, memorize, normalizeUserChatInput, recall, resolveApproval, run, serveToolsOverStdio, subscribe, stop, } from "./api.js";
 export { tool } from "./tools.js";

package/dist/package-version.d.ts

@@ -1 +1 @@
-export declare const AGENT_HARNESS_VERSION = "0.0.152";
+export declare const AGENT_HARNESS_VERSION = "0.0.153";

package/dist/package-version.js

@@ -1 +1 @@
-export const AGENT_HARNESS_VERSION = "0.0.152";
+export const AGENT_HARNESS_VERSION = "0.0.153";

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

@@ -6,6 +6,9 @@ type PersistMemoryRecordsOptions = {
     threadId: string;
     runId: string;
     agentId: string;
+    workspaceId: string;
+    userId: string;
+    projectId: string;
     recordedAt: string;
 };
 export declare function renderMemoryRecordsMarkdown(title: string, records: MemoryRecord[]): string;

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

@@ -118,6 +118,9 @@ function createMemoryRecord(candidate, options) {
             threadId: options.threadId,
             runId: options.runId,
             agentId: options.agentId,
+            workspaceId: options.workspaceId,
+            userId: options.userId,
+            projectId: options.projectId,
             ...(candidate.provenance ?? {}),
         },
         revision: 1,

package/dist/runtime/harness.d.ts

@@ -1,4 +1,4 @@
-import type { ApprovalRecord, CancelOptions, HarnessEvent, HarnessStreamItem, RuntimeHealthSnapshot, MessageContent, RunRecord, RunStartOptions, RestartConversationOptions, RuntimeAdapterOptions, ResumeOptions, RunOptions, RunResult, RunSummary, ThreadSummary, ThreadRecord, WorkspaceBundle } from "../contracts/types.js";
+import type { ApprovalRecord, CancelOptions, HarnessEvent, HarnessStreamItem, RuntimeHealthSnapshot, MessageContent, RunRecord, RunStartOptions, RestartConversationOptions, RuntimeAdapterOptions, ResumeOptions, RunOptions, RunResult, RunSummary, MemorizeInput, MemorizeResult, RecallInput, RecallResult, ThreadSummary, ThreadRecord, WorkspaceBundle } from "../contracts/types.js";
 import { type ToolMcpServerOptions } from "../mcp.js";
 import { type InventoryAgentRecord, type InventorySkillRecord } from "./harness/system/inventory.js";
 import type { RequirementAssessmentOptions } from "./harness/system/skill-requirements.js";
@@ -62,6 +62,8 @@ export declare class AgentHarnessRuntime {
         threadId?: string;
         state?: RunSummary["state"];
     }): Promise<RunSummary[]>;
+    memorize(input: MemorizeInput): Promise<MemorizeResult>;
+    recall(input: RecallInput): Promise<RecallResult>;
     getRun(runId: string): Promise<RunRecord | null>;
     private getSession;
     getThread(threadId: string): Promise<ThreadRecord | null>;
@@ -93,8 +95,13 @@ export declare class AgentHarnessRuntime {
     private finalizeCancelledRun;
     private invokeWithHistory;
     private resolveMemoryNamespace;
+    private getWorkspaceId;
+    private resolveRecallScopes;
+    private matchesRecallScope;
+    private getMemoryScopeBoost;
     private buildRuntimeMemoryContext;
     private persistRuntimeMemoryCandidates;
+    private persistStructuredMemoryCandidates;
     private appendMemoryDigest;
     private resolvePersistedRunPriority;
     private enqueuePendingRunSlot;

package/dist/runtime/harness.js

@@ -243,6 +243,78 @@ export class AgentHarnessRuntime {
     async listRuns(filter) {
         return this.persistence.listRuns(filter);
     }
+    async memorize(input) {
+        const binding = this.defaultRuntimeEntryBinding;
+        if (!binding) {
+            throw new Error("memorize requires a runtime entry binding.");
+        }
+        if (!Array.isArray(input.records)) {
+            throw new Error("memorize requires input.records to be an array.");
+        }
+        const candidates = input.records
+            .filter((record) => typeof record === "object" && record !== null)
+            .filter((record) => record.noStore !== true);
+        if (candidates.length === 0) {
+            return { records: [], decisions: [] };
+        }
+        if (candidates.some((record) => typeof record.content !== "string" || record.content.trim().length === 0)) {
+            throw new Error("memorize requires every record to include non-empty content.");
+        }
+        if (candidates.some((record) => (record.scope ?? "thread") === "thread") && !input.threadId) {
+            throw new Error("memorize requires threadId when storing thread-scoped memory.");
+        }
+        const recordedAt = input.recordedAt ?? new Date().toISOString();
+        const runId = input.runId ?? createPersistentId(new Date(recordedAt));
+        const threadId = input.threadId ?? `memory-api-${runId}`;
+        return this.persistStructuredMemoryCandidates(binding, {
+            candidates: candidates.map((record) => ({ ...record, content: record.content.trim() })),
+            threadId,
+            runId,
+            agentId: input.agentId ?? binding.agent.id,
+            userId: input.userId,
+            projectId: input.projectId,
+            recordedAt,
+            storeCandidateLog: true,
+        });
+    }
+    async recall(input) {
+        const binding = this.defaultRuntimeEntryBinding;
+        if (!binding) {
+            throw new Error("recall requires a runtime entry binding.");
+        }
+        if (typeof input.query !== "string" || input.query.trim().length === 0) {
+            throw new Error("recall requires a non-empty query.");
+        }
+        const workspaceId = this.getWorkspaceId(binding);
+        const agentId = input.agentId ?? binding.agent.id;
+        const userId = input.userId ?? "default";
+        const projectId = input.projectId ?? workspaceId;
+        const scopes = this.resolveRecallScopes(input);
+        const topK = typeof input.topK === "number" && Number.isInteger(input.topK) && input.topK > 0
+            ? input.topK
+            : (this.runtimeMemoryPolicy?.retrieval.defaultTopK ?? 5);
+        const kinds = input.kinds?.length ? new Set(input.kinds) : null;
+        const items = (await listMemoryRecordsForScopes(this.runtimeMemoryStore, scopes))
+            .filter((record) => this.matchesRecallScope(record, {
+            threadId: input.threadId,
+            agentId,
+            workspaceId: input.workspaceId ?? workspaceId,
+            userId,
+            projectId,
+        }))
+            .filter((record) => (input.includeStale ? record.status === "active" || record.status === "stale" : record.status === "active"))
+            .filter((record) => (kinds ? kinds.has(record.kind) : true))
+            .map((record) => ({
+            record,
+            score: scoreMemoryText(input.query.trim(), `${record.summary}\n${record.content}`, this.getMemoryScopeBoost(record.scope)) +
+                Math.max(0, 1 - ((Date.now() - Date.parse(record.lastConfirmedAt)) / (1000 * 60 * 60 * 24 * 365))) +
+                record.confidence,
+        }))
+            .sort((left, right) => right.score - left.score)
+            .slice(0, topK)
+            .map(({ record }) => record);
+        return { items };
+    }
     async getRun(runId) {
         return this.persistence.getRun(runId);
     }
@@ -392,8 +464,7 @@ export class AgentHarnessRuntime {
         }
     }
     resolveMemoryNamespace(scope, binding, options = {}) {
-        const workspaceRoot = binding.harnessRuntime.workspaceRoot ?? this.workspace.workspaceRoot;
-        const workspaceId = path.basename(workspaceRoot) || "default";
+        const workspaceId = this.getWorkspaceId(binding);
         const template = this.runtimeMemoryPolicy?.namespaces[scope] ?? `memories/${scope}s/{${scope}Id}`;
         return resolveMemoryNamespace(template, {
             threadId: options.threadId,
@@ -403,6 +474,50 @@ export class AgentHarnessRuntime {
             projectId: options.projectId ?? workspaceId,
         });
     }
+    getWorkspaceId(binding) {
+        const workspaceRoot = binding.harnessRuntime.workspaceRoot ?? this.workspace.workspaceRoot;
+        return path.basename(workspaceRoot) || "default";
+    }
+    resolveRecallScopes(input) {
+        if (Array.isArray(input.scopes) && input.scopes.length > 0) {
+            return Array.from(new Set(input.scopes));
+        }
+        const scopes = new Set(["thread", "agent", "workspace"]);
+        if (input.userId) {
+            scopes.add("user");
+        }
+        if (input.projectId) {
+            scopes.add("project");
+        }
+        return Array.from(scopes);
+    }
+    matchesRecallScope(record, filters) {
+        if (record.scope === "thread") {
+            return typeof filters.threadId === "string" && String(record.provenance.threadId ?? "") === filters.threadId;
+        }
+        if (record.scope === "agent") {
+            return String(record.provenance.agentId ?? "") === filters.agentId;
+        }
+        if (record.scope === "workspace") {
+            return String(record.provenance.workspaceId ?? filters.workspaceId) === filters.workspaceId;
+        }
+        if (record.scope === "user") {
+            return String(record.provenance.userId ?? "default") === filters.userId;
+        }
+        return String(record.provenance.projectId ?? filters.workspaceId) === filters.projectId;
+    }
+    getMemoryScopeBoost(scope) {
+        if (scope === "thread") {
+            return 4;
+        }
+        if (scope === "agent") {
+            return 2;
+        }
+        if (scope === "workspace") {
+            return 1;
+        }
+        return 0;
+    }
     async buildRuntimeMemoryContext(binding, threadId, input) {
         const query = typeof input === "string" ? input : JSON.stringify(input ?? "");
         const ranked = (await listMemoryRecordsForScopes(this.runtimeMemoryStore, ["thread", "agent", "workspace"]))
@@ -452,30 +567,47 @@ export class AgentHarnessRuntime {
         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");
-        const recordedAt = new Date().toISOString();
-        await this.runtimeMemoryStore.put(["memories", "candidates", threadId], `${runId}.json`, {
-            runId,
-            threadId,
-            storedAt: recordedAt,
-            candidates,
-        });
-        await persistStructuredMemoryRecords({
-            store: this.runtimeMemoryStore,
+        await this.persistStructuredMemoryCandidates(binding, {
             candidates,
             threadId,
             runId,
             agentId: binding.agent.id,
-            recordedAt,
+            recordedAt: new Date().toISOString(),
+            storeCandidateLog: true,
+        });
+    }
+    async persistStructuredMemoryCandidates(binding, input) {
+        const workspaceId = this.getWorkspaceId(binding);
+        const userId = input.userId ?? "default";
+        const projectId = input.projectId ?? workspaceId;
+        const threadCandidates = input.candidates.filter((candidate) => (candidate.scope ?? "thread") === "thread");
+        const workspaceCandidates = input.candidates.filter((candidate) => (candidate.scope ?? "thread") === "workspace");
+        const agentCandidates = input.candidates.filter((candidate) => (candidate.scope ?? "thread") === "agent");
+        if (input.storeCandidateLog) {
+            await this.runtimeMemoryStore.put(["memories", "candidates", input.threadId], `${input.runId}.json`, {
+                runId: input.runId,
+                threadId: input.threadId,
+                storedAt: input.recordedAt,
+                candidates: input.candidates,
+            });
+        }
+        const persisted = await persistStructuredMemoryRecords({
+            store: this.runtimeMemoryStore,
+            candidates: input.candidates,
+            threadId: input.threadId,
+            runId: input.runId,
+            agentId: input.agentId,
+            workspaceId,
+            userId,
+            projectId,
+            recordedAt: input.recordedAt,
         });
         const writes = [];
         if (threadCandidates.length > 0) {
-            writes.push(this.appendMemoryDigest(this.resolveMemoryNamespace("thread", binding, { threadId }), "tool-memory.md", threadCandidates, 12, "Thread Tool Memory"));
+            writes.push(this.appendMemoryDigest(this.resolveMemoryNamespace("thread", binding, { threadId: input.threadId }), "tool-memory.md", threadCandidates, 12, "Thread Tool Memory"));
             writes.push(consolidateStructuredMemoryScope({
                 store: this.runtimeMemoryStore,
-                namespace: this.resolveMemoryNamespace("thread", binding, { threadId }),
+                namespace: this.resolveMemoryNamespace("thread", binding, { threadId: input.threadId }),
                 title: "Thread Structured Memory",
                 scope: "thread",
                 maxEntries: 12,
@@ -505,6 +637,7 @@ export class AgentHarnessRuntime {
             }));
         }
         await Promise.all(writes);
+        return persisted;
     }
     async appendMemoryDigest(namespace, key, candidates, maxEntries, title) {
         const existing = await this.runtimeMemoryStore.get(namespace, key);

package/package.json

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