@botbotgo/agent-harness 0.0.148 → 0.0.150

package/README.md

@@ -43,6 +43,8 @@ What you get on day one:
 
 - a runtime that keeps `runs`, `threads`, `approvals`, and `events` as inspectable product records
 - a recovery path that survives interruption, restart, and operator decisions
+- stable run correlation and continuity metadata so operators can join one persisted run to logs, traces, and fallback transitions
+- approval defaults for sensitive durable memory writes and write-like MCP calls instead of relying on each tool definition to remember governance
 - one workspace-shaped assembly model instead of app-specific runtime glue
 - one stable runtime contract even when execution backends change underneath
 
@@ -75,7 +77,9 @@ Concretely, that means:
 
 - a product-facing approval and operator surface instead of backend-specific middleware state
 - persisted `runs`, `threads`, `approvals`, and `events` as stable runtime records
+- runtime-owned inspection fields such as tracing correlation ids and continuity metadata instead of provider-private observability handles
 - restart-safe recovery and continuation as system-managed behavior
+- default runtime governance for high-risk memory and MCP side effects
 - YAML-owned routing, concurrency, maintenance, and recovery policy
 - adapter isolation so backend replacement does not redefine the public runtime model
 
@@ -115,6 +119,7 @@ In practice, the harness exists for the parts that are painful to rebuild inside
 
 - approval inboxes and human decision flow
 - persisted runs, threads, and inspectable event history
+- run correlation, continuity, and recovery inspection that still works after a stream fallback or restart
 - runtime-managed recovery after interrupts, failures, or process restart
 - queueing, concurrency, maintenance, and operational policy
 - stable runtime records that stay usable even if the backend changes
@@ -173,6 +178,7 @@ Real products need a runtime that can answer harder questions:
 
 - It treats `runs`, `threads`, `approvals`, `events`, and recovery as first-class product records
 - It gives operators a runtime control surface instead of exposing raw backend internals
+- It keeps observability and governance runtime-owned with trace correlation, continuity metadata, and approval defaults for sensitive side effects
 - It keeps checkpoint resume system-managed instead of promoting checkpoint internals into the primary API
 - It lets YAML own assembly and operating policy while code keeps a tiny surface
 - It goes deep on runtime concerns that upstream libraries do not fully productize

package/README.zh.md

@@ -43,6 +43,8 @@
 
 - 把 `runs`、`threads`、`approvals`、`events` 作为可查询产品记录保存下来的 runtime
 - 能跨中断、重启和人工决策继续推进的恢复路径
+- 稳定的 run 关联与连续性元数据，让一次持久化运行能和日志、trace、fallback 过程对齐
+- 对敏感 durable memory 写入和写类 MCP 调用默认走审批，而不是把治理责任留给每个工具定义自己记住
 - 一个工作区形态的装配模型，而不是每个应用各写一套运行时胶水
 - 即使底层 execution backend 变化，也尽量保持稳定的 runtime 契约
 
@@ -75,7 +77,9 @@ AI 让 agent 逻辑、工具调用和工作流代码更容易生成，真正变
 
 - 面向产品的审批与运维控制面，而不是 backend 专属的中间件状态
 - 稳定持久化的 `runs`、`threads`、`approvals` 与 `events` 记录
+- 由运行时持有的 tracing correlation id 与 continuity metadata，而不是 provider 私有观测句柄
 - 由系统托管的重启恢复与中断续跑
+- 面向高风险 memory / MCP 副作用的默认治理策略
 - 由 YAML 持有的路由、并发、维护与恢复策略
 - 通过适配器隔离 backend 变化，不让公共运行时模型漂移
 
@@ -115,6 +119,7 @@ AI 让 agent 逻辑、工具调用和工作流代码更容易生成，真正变
 
 - 审批收件箱与人工决策流
 - 持久化的 runs、threads 与可查询事件历史
+- 即使发生 stream fallback 或进程重启也还能成立的 run 关联、连续性与恢复观测
 - 中断、失败或进程重启后的运行时托管恢复
 - 队列、并发、维护与运维策略
 - 即使后端变更也保持稳定的运行时记录模型
@@ -170,6 +175,7 @@ AI 让 agent 逻辑、工具调用和工作流代码更容易生成，真正变
 
 - 将 `runs`、`threads`、`approvals`、`events` 与恢复视为一等产品记录
 - 给运维侧提供运行时控制面，而不是暴露原始后端内部结构
+- 将可观测性与治理留在运行时：包括 trace correlation、continuity metadata，以及高风险副作用的默认审批
 - 将 checkpoint 恢复作为系统管理的行为，而不是把 checkpoint 细节抬成主 API
 - 复杂装配与运行策略交给 YAML，代码面保持极小
 - 在上游库未充分产品化的运行时问题上做深做透

package/dist/package-version.d.ts

@@ -1 +1 @@
-export declare const AGENT_HARNESS_VERSION = "0.0.147";
+export declare const AGENT_HARNESS_VERSION = "0.0.149";

package/dist/package-version.js

@@ -1 +1 @@
-export const AGENT_HARNESS_VERSION = "0.0.147";
+export const AGENT_HARNESS_VERSION = "0.0.149";

package/dist/runtime/harness/events/events.js

@@ -59,8 +59,16 @@ export async function requestApprovalAndEmitEvent(runtime, threadId, runId, inpu
     return { approval, event };
 }
 export async function emitSyntheticFallbackEvent(runtime, threadId, runId, selectedAgentId, error, sequence = 3) {
+    const payload = typeof error === "object" && error !== null && "reason" in error
+        ? {
+            ...error,
+            selectedAgentId,
+        }
+        : {
+            reason: error instanceof Error ? error.message : String(error),
+            selectedAgentId,
+        };
     await emitHarnessEvent(runtime, threadId, runId, sequence, "runtime.synthetic_fallback", {
-        reason: error instanceof Error ? error.message : String(error),
-        selectedAgentId,
+        ...payload,
     });
 }

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

@@ -46,6 +46,7 @@ export async function* streamHarnessRun(options) {
     let nonUpstreamStreamActivityObserved = false;
     let currentAgentId = options.selectedAgentId;
     let delegationChain = [options.selectedAgentId];
+    let syntheticFallback;
     try {
         const [priorHistory, acquiredReleaseRunSlot] = await Promise.all([
             priorHistoryPromise,
@@ -237,6 +238,13 @@ export async function* streamHarnessRun(options) {
             return;
         }
         try {
+            syntheticFallback = {
+                strategy: "stream-to-invoke",
+                sourceStage: "stream",
+                reason: error instanceof Error ? error.message : String(error),
+                outcome: "recovered",
+            };
+            await options.emitSyntheticFallback(options.threadId, options.runId, options.selectedAgentId, syntheticFallback);
             const actual = await options.invokeWithHistory(options.binding, options.input, options.threadId, options.runId);
             await options.appendAssistantMessage(options.threadId, options.runId, actual.output);
             if (Array.isArray(actual.contentBlocks) && actual.contentBlocks.length > 0) {
@@ -249,6 +257,10 @@ export async function* streamHarnessRun(options) {
                     threadId: options.threadId,
                     runId: options.runId,
                     agentId: currentAgentId,
+                    metadata: {
+                        ...(actual.metadata ?? {}),
+                        syntheticFallback,
+                    },
                 },
             };
             yield {
@@ -260,7 +272,13 @@ export async function* streamHarnessRun(options) {
             return;
         }
         catch (invokeError) {
-            await options.emitSyntheticFallback(options.threadId, options.runId, options.selectedAgentId, invokeError);
+            syntheticFallback = {
+                strategy: "stream-to-invoke",
+                sourceStage: "stream",
+                reason: invokeError instanceof Error ? invokeError.message : String(invokeError),
+                outcome: "failed",
+            };
+            await options.emitSyntheticFallback(options.threadId, options.runId, options.selectedAgentId, syntheticFallback);
             const runtimeFailure = renderRuntimeFailure(invokeError);
             yield {
                 type: "event",
@@ -285,6 +303,9 @@ export async function* streamHarnessRun(options) {
                     state: "failed",
                     output: runtimeFailure,
                     finalMessageText: runtimeFailure,
+                    metadata: {
+                        syntheticFallback,
+                    },
                 },
             };
             return;

package/package.json

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