@botbotgo/agent-harness 0.0.268 → 0.0.270

package/dist/protocol/a2a/http.js

@@ -11,6 +11,10 @@ function writeJson(response, statusCode, payload) {
     response.setHeader("content-type", "application/json; charset=utf-8");
     response.end(JSON.stringify(payload));
 }
+function writeA2aDiscoveryHeaders(response) {
+    response.setHeader("A2A-Version", "1.0");
+    response.setHeader("A2A-Supported-Versions", SUPPORTED_A2A_VERSIONS.join(", "));
+}
 function writeSseHeaders(response) {
     response.statusCode = 200;
     response.setHeader("content-type", "text/event-stream; charset=utf-8");
@@ -356,18 +360,19 @@ function toSessionRecord(session) {
     if (!session) {
         return null;
     }
+    const typed = session;
     return {
-        sessionId: session.threadId,
-        entryAgentId: session.entryAgentId,
-        currentAgentId: session.currentAgentId,
-        currentState: session.currentState,
-        latestRequestId: session.latestRunId,
-        createdAt: session.createdAt,
-        updatedAt: session.updatedAt,
-        messages: session.messages,
-        requests: session.runs.map((run) => ({
-            requestId: run.runId,
-            sessionId: run.threadId,
+        sessionId: typed.sessionId ?? typed.threadId ?? "",
+        entryAgentId: typed.entryAgentId,
+        currentAgentId: typed.currentAgentId,
+        currentState: typed.currentState,
+        latestRequestId: typed.latestRequestId ?? typed.latestRunId ?? "",
+        createdAt: typed.createdAt,
+        updatedAt: typed.updatedAt,
+        messages: typed.messages,
+        requests: (typed.requests ?? typed.runs ?? []).map((run) => ({
+            requestId: run.requestId,
+            sessionId: run.sessionId,
             agentId: run.agentId,
             executionMode: run.executionMode,
             adapterKind: run.adapterKind,
@@ -392,25 +397,26 @@ function toRequestRecord(request) {
     if (!request) {
         return null;
     }
+    const typed = request;
     return {
-        requestId: request.runId,
-        sessionId: request.threadId,
-        agentId: request.agentId,
-        executionMode: request.executionMode,
-        adapterKind: request.adapterKind,
-        createdAt: request.createdAt,
-        updatedAt: request.updatedAt,
-        state: request.state,
-        checkpointRef: request.checkpointRef,
-        resumable: request.resumable,
-        startedAt: request.startedAt,
-        endedAt: request.endedAt,
-        lastActivityAt: request.lastActivityAt,
-        currentAgentId: request.currentAgentId,
-        delegationChain: request.delegationChain,
-        runtimeSnapshot: request.runtimeSnapshot,
-        traceItems: request.traceItems,
-        runtimeTimeline: request.runtimeTimeline,
+        requestId: typed.requestId ?? typed.runId ?? "",
+        sessionId: typed.sessionId ?? typed.threadId ?? "",
+        agentId: typed.agentId,
+        executionMode: typed.executionMode,
+        adapterKind: typed.adapterKind,
+        createdAt: typed.createdAt,
+        updatedAt: typed.updatedAt,
+        state: typed.state,
+        checkpointRef: typed.checkpointRef,
+        resumable: typed.resumable,
+        startedAt: typed.startedAt,
+        endedAt: typed.endedAt,
+        lastActivityAt: typed.lastActivityAt,
+        currentAgentId: typed.currentAgentId,
+        delegationChain: typed.delegationChain,
+        runtimeSnapshot: typed.runtimeSnapshot,
+        traceItems: typed.traceItems,
+        runtimeTimeline: typed.runtimeTimeline,
     };
 }
 function buildTaskFromSessionAndRequest(session, request, approvals, output, failureMessage) {
@@ -473,8 +479,8 @@ async function buildTaskFromRuntime(runtime, requestId) {
     if (!request) {
         return null;
     }
-    const session = await runtime.getThread(request.threadId);
-    const approvals = await runtime.listApprovals({ threadId: request.threadId, runId: request.runId });
+    const session = await runtime.getThread(request.sessionId);
+    const approvals = await runtime.listApprovals({ sessionId: request.sessionId, requestId: request.requestId });
     return buildTaskFromSessionAndRequest(toSessionRecord(session), toRequestRecord(request), approvals);
 }
 async function hydrateTaskStateFromEvents(runtime, task) {
@@ -508,7 +514,7 @@ async function listTasksFromRuntime(runtime, params) {
     });
     const startIndex = params.cursor ? Number.parseInt(Buffer.from(params.cursor, "base64url").toString("utf8"), 10) || 0 : 0;
     const page = runs.slice(startIndex, startIndex + params.limit);
-    const tasks = (await Promise.all(page.map((run) => buildTaskFromRuntime(runtime, run.runId)))).filter((task) => Boolean(task));
+    const tasks = (await Promise.all(page.map((run) => buildTaskFromRuntime(runtime, run.requestId)))).filter((task) => Boolean(task));
     const nextIndex = startIndex + page.length;
     const nextPageToken = nextIndex < runs.length ? Buffer.from(String(nextIndex), "utf8").toString("base64url") : "";
     return {
@@ -718,12 +724,12 @@ async function* streamSendMessageTaskUpdates(runtime, options, method) {
     let emittedInitialTask = false;
     for await (const item of runtime.streamEvents(options)) {
         if (item.type === "event") {
-            runId = runId ?? item.event.runId;
+            runId = runId ?? item.event.requestId;
             if (item.event.eventType === "output.delta" && typeof item.event.payload.content === "string") {
                 streamedText += item.event.payload.content;
             }
             if (item.event.eventType === "run.created" || item.event.eventType === "run.state.changed" || item.event.eventType === "output.delta" || item.event.eventType === "approval.requested") {
-                const task = withStreamingStatusText(await buildTaskFromRuntime(runtime, item.event.runId), streamedText || undefined);
+                const task = withStreamingStatusText(await buildTaskFromRuntime(runtime, item.event.requestId), streamedText || undefined);
                 if (task) {
                     yield { task, mode: emittedInitialTask ? "status-update" : "task" };
                     emittedInitialTask = true;
@@ -732,8 +738,8 @@ async function* streamSendMessageTaskUpdates(runtime, options, method) {
             continue;
         }
         if (item.type === "result") {
-            runId = item.result.runId;
-            const task = withRunResult(await buildTaskFromRuntime(runtime, item.result.runId), item.result, streamedText || item.result.output);
+            runId = item.result.requestId;
+            const task = withRunResult(await buildTaskFromRuntime(runtime, item.result.requestId), item.result, streamedText || item.result.output);
             yield { task, mode: emittedInitialTask ? "status-update" : "task" };
             return;
         }
@@ -810,7 +816,7 @@ async function streamExistingTaskUpdates(runtime, response, id, method, taskId)
             }
         };
         const unsubscribe = runtime.subscribe((event) => {
-            if (event.runId !== taskId) {
+            if (event.requestId !== taskId) {
                 return;
             }
             if (event.eventType !== "run.state.changed"
@@ -893,10 +899,10 @@ export async function serveA2aOverHttp(runtime, options = {}) {
     };
     const pushRelevantEventTypes = new Set(["run.state.changed", "approval.requested", "approval.resolved"]);
     const unsubscribePushNotifications = runtime.subscribe((event) => {
-        if (!pushRelevantEventTypes.has(event.eventType) || !pushConfigsByTask.has(event.runId)) {
+        if (!pushRelevantEventTypes.has(event.eventType) || !pushConfigsByTask.has(event.requestId)) {
             return;
         }
-        void dispatchPushNotificationsForTask(event.runId);
+        void dispatchPushNotificationsForTask(event.requestId);
     });
     const httpServer = createServer(async (request, response) => {
         try {
@@ -911,6 +917,19 @@ export async function serveA2aOverHttp(runtime, options = {}) {
                 });
                 return;
             }
+            writeA2aDiscoveryHeaders(response);
+            if (request.method === "OPTIONS" && (requestUrl.pathname === rpcPath || requestUrl.pathname === agentCardPath || requestUrl.pathname === "/.well-known/agent.json")) {
+                response.statusCode = 204;
+                response.setHeader("Allow", "GET,HEAD,POST,OPTIONS");
+                response.end();
+                return;
+            }
+            if (request.method === "HEAD" && (requestUrl.pathname === agentCardPath || requestUrl.pathname === "/.well-known/agent.json")) {
+                response.statusCode = 200;
+                response.setHeader("content-type", "application/json; charset=utf-8");
+                response.end();
+                return;
+            }
             if (request.method === "GET" && (requestUrl.pathname === agentCardPath || requestUrl.pathname === "/.well-known/agent.json")) {
                 writeJson(response, 200, buildAgentCard(runtime, buildCardOptions()));
                 return;
@@ -934,12 +953,12 @@ export async function serveA2aOverHttp(runtime, options = {}) {
                         const result = await runtime.run({
                             agentId: parsed.agentId ?? options.defaultAgentId,
                             input: parsed.input,
-                            ...(parsed.sessionId ? { threadId: parsed.sessionId } : {}),
+                            ...(parsed.sessionId ? { sessionId: parsed.sessionId } : {}),
                             invocation: attachServiceParameters(parsed.invocation, serviceParameters),
                         });
-                        const session = await runtime.getThread(result.threadId);
-                        const requestRecord = await runtime.getRun(result.runId);
-                        const approvals = await runtime.listApprovals({ threadId: result.threadId, runId: result.runId });
+                        const session = await runtime.getThread(result.sessionId);
+                        const requestRecord = await runtime.getRun(result.requestId);
+                        const approvals = await runtime.listApprovals({ sessionId: result.sessionId, requestId: result.requestId });
                         const task = buildTaskFromSessionAndRequest(toSessionRecord(session), toRequestRecord(requestRecord), approvals, result.output);
                         if (task && parsed.pushNotificationConfig) {
                             registerPushNotificationConfig(task.id, parsed.pushNotificationConfig);
@@ -948,6 +967,10 @@ export async function serveA2aOverHttp(runtime, options = {}) {
                         writeJson(response, 200, toSuccess(payload.id ?? null, toSendMessageResult(payload.method, task)));
                         return;
                     }
+                    if (payload.method === "GetAgentCard") {
+                        writeJson(response, 200, toSuccess(payload.id ?? null, buildAgentCard(runtime, buildCardOptions())));
+                        return;
+                    }
                     if (payload.method === "message/stream" || payload.method === "SendStreamingMessage") {
                         if (!acceptsSse(request)) {
                             writeJson(response, 406, toError(payload.id ?? null, -32004, "A2A streaming requires `Accept: text/event-stream`."));
@@ -958,7 +981,7 @@ export async function serveA2aOverHttp(runtime, options = {}) {
                         const sourceIterator = streamSendMessageTaskUpdates(runtime, {
                             agentId: parsed.agentId ?? options.defaultAgentId,
                             input: parsed.input,
-                            ...(parsed.sessionId ? { threadId: parsed.sessionId } : {}),
+                            ...(parsed.sessionId ? { sessionId: parsed.sessionId } : {}),
                             invocation: attachServiceParameters(parsed.invocation, serviceParameters),
                         }, payload.method);
                         const iterator = (async function* () {
@@ -991,8 +1014,8 @@ export async function serveA2aOverHttp(runtime, options = {}) {
                     }
                     if (payload.method === "tasks/cancel" || payload.method === "CancelTask") {
                         const { taskId } = parseTaskLocatorParams(payload.params);
-                        const result = await runtime.cancelRun({ runId: taskId, reason: "Cancelled via A2A bridge." });
-                        const task = await buildTaskFromRuntime(runtime, result.runId);
+                        const result = await runtime.cancelRun({ requestId: taskId, reason: "Cancelled via A2A bridge." });
+                        const task = await buildTaskFromRuntime(runtime, result.requestId);
                         writeJson(response, 200, toSuccess(payload.id ?? null, task));
                         return;
                     }

package/dist/protocol/ag-ui/http.js

@@ -51,8 +51,8 @@ function toRunStarted(event, input) {
     return {
         type: "RUN_STARTED",
         timestamp: createTimestamp(),
-        threadId: event.threadId,
-        runId: event.runId,
+        threadId: event.sessionId,
+        runId: event.requestId,
         input,
     };
 }
@@ -187,19 +187,19 @@ export async function serveAgUiOverHttp(runtime, options = {}) {
             const result = await runtime.run({
                 agentId: input.agentId,
                 input: input.input,
-                ...(input.sessionId ? { threadId: input.sessionId } : {}),
+                ...(input.sessionId ? { sessionId: input.sessionId } : {}),
                 ...(input.invocation ? { invocation: input.invocation } : {}),
                 listeners: {
                     onEvent: async (event) => {
                         if (event.eventType === "run.created") {
-                            runId = event.runId;
-                            threadId = event.threadId;
+                            runId = event.requestId;
+                            threadId = event.sessionId;
                             await writeSseEvent(response, toRunStarted(event, input.input));
                             return;
                         }
                         if (event.eventType === "output.delta") {
-                            runId = runId ?? event.runId;
-                            threadId = threadId ?? event.threadId;
+                            runId = runId ?? event.requestId;
+                            threadId = threadId ?? event.sessionId;
                             const delta = typeof event.payload.content === "string" ? event.payload.content : "";
                             if (!delta) {
                                 return;
@@ -301,8 +301,8 @@ export async function serveAgUiOverHttp(runtime, options = {}) {
                     },
                 },
             });
-            runId = runId ?? result.runId;
-            threadId = threadId ?? result.threadId;
+            runId = runId ?? result.requestId;
+            threadId = threadId ?? result.sessionId;
             if (!textMessageStarted && result.output) {
                 await ensureTextStart();
                 await writeSseEvent(response, {

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

@@ -20,8 +20,8 @@ export function finalizeInvocationResult(params) {
     const stateSnapshot = buildStateSnapshot(result);
     const memoryCandidates = executedToolResults.flatMap((toolResult) => toolResult.memoryCandidates ?? []);
     return {
-        threadId,
-        runId,
+        sessionId: threadId,
+        requestId: runId,
         agentId: bindingAgentId,
         state: Array.isArray(result.__interrupt__) && result.__interrupt__.length > 0 ? "waiting_for_approval" : "completed",
         interruptContent,

package/dist/runtime/adapter/tool/tool-hitl.d.ts

@@ -1,7 +1,9 @@
 import type { CompiledTool } from "../../../contracts/types.js";
 import type { CompiledAgentBinding } from "../../../contracts/types.js";
+import type { RuntimeGovernanceDecisionMode } from "../../../contracts/types.js";
 type InterruptFn = <I = unknown, R = unknown>(value: I) => R;
+export declare function resolveToolApprovalDecisionMode(compiledTool: CompiledTool, binding?: CompiledAgentBinding): RuntimeGovernanceDecisionMode;
 export declare function toolRequiresRuntimeApproval(compiledTool: CompiledTool): boolean;
-export declare function wrapToolForHumanInTheLoop<T>(resolvedTool: T, compiledTool: CompiledTool, interruptFn?: InterruptFn): T;
+export declare function wrapToolForHumanInTheLoop<T>(resolvedTool: T, compiledTool: CompiledTool, binding?: CompiledAgentBinding, interruptFn?: InterruptFn): T;
 export declare function wrapToolForExecution<T>(resolvedTool: T, compiledTool: CompiledTool, binding?: CompiledAgentBinding, interruptFn?: InterruptFn): T;
 export {};

package/dist/runtime/adapter/tool/tool-hitl.js

@@ -14,6 +14,16 @@ function asRecord(value) {
 function asString(value) {
     return typeof value === "string" && value.trim().length > 0 ? value.trim() : undefined;
 }
+function readApprovalDecisionMode(value) {
+    if (value === "none" ||
+        value === "manual" ||
+        value === "auto-approve" ||
+        value === "auto-reject" ||
+        value === "deny-and-continue") {
+        return value;
+    }
+    return undefined;
+}
 function readApprovalOverride(compiledTool) {
     if (compiledTool.config?.requireApproval === true) {
         return true;
@@ -59,11 +69,62 @@ function requiresApprovalForHighRiskMcpWrite(compiledTool) {
         .join(" ");
     return WRITE_LIKE_REMOTE_TOOL_PATTERN.test(targetText);
 }
-export function toolRequiresRuntimeApproval(compiledTool) {
+function matchesGovernanceToolPolicy(rule, compiledTool) {
+    const match = asRecord(rule.match) ?? rule;
+    const toolName = asString(match.toolName);
+    const category = asString(match.category);
+    const toolType = asString(match.toolType);
+    const compiledCategory = compiledTool.type === "mcp"
+        ? "mcp"
+        : compiledTool.type === "backend"
+            ? "backend"
+            : compiledTool.type === "provider"
+                ? "provider-native"
+                : "local";
+    return (!toolName || toolName === compiledTool.name)
+        && (!category || category === compiledCategory)
+        && (!toolType || toolType === compiledTool.type);
+}
+function readToolApprovalModeFromGovernance(compiledTool, binding) {
+    const governance = asRecord(binding?.harnessRuntime.governance);
+    const overrides = Array.isArray(governance?.toolPolicies) ? governance.toolPolicies : [];
+    for (const rule of overrides) {
+        const typedRule = asRecord(rule);
+        if (!typedRule || !matchesGovernanceToolPolicy(typedRule, compiledTool)) {
+            continue;
+        }
+        const overrideMode = readApprovalDecisionMode(typedRule.decisionMode ?? typedRule.approvalMode);
+        if (overrideMode) {
+            return overrideMode;
+        }
+    }
+    return undefined;
+}
+function readToolApprovalModeFromConfig(compiledTool) {
+    const approval = asRecord(compiledTool.config?.approval);
+    return readApprovalDecisionMode(approval?.mode ??
+        approval?.decisionMode ??
+        compiledTool.config?.approvalMode);
+}
+export function resolveToolApprovalDecisionMode(compiledTool, binding) {
     if (compiledTool.hitl?.enabled === true) {
-        return true;
+        return "manual";
+    }
+    const governanceMode = readToolApprovalModeFromGovernance(compiledTool, binding);
+    if (governanceMode) {
+        return governanceMode;
+    }
+    const configuredMode = readToolApprovalModeFromConfig(compiledTool);
+    if (configuredMode) {
+        return configuredMode;
     }
-    return readApprovalOverride(compiledTool) || requiresApprovalForSensitiveMemoryWrite(compiledTool) || requiresApprovalForHighRiskMcpWrite(compiledTool);
+    if (readApprovalOverride(compiledTool) || requiresApprovalForSensitiveMemoryWrite(compiledTool) || requiresApprovalForHighRiskMcpWrite(compiledTool)) {
+        return "manual";
+    }
+    return "none";
+}
+export function toolRequiresRuntimeApproval(compiledTool) {
+    return resolveToolApprovalDecisionMode(compiledTool) === "manual";
 }
 function toolApprovalReason(compiledTool) {
     if (compiledTool.hitl?.enabled === true) {
@@ -101,17 +162,25 @@ function resolveApprovedInput(originalInput, resumeValue) {
     }
     return originalInput;
 }
-export function wrapToolForHumanInTheLoop(resolvedTool, compiledTool, interruptFn = interrupt) {
-    if (!toolRequiresRuntimeApproval(compiledTool) || typeof resolvedTool !== "object" || resolvedTool === null) {
+export function wrapToolForHumanInTheLoop(resolvedTool, compiledTool, binding, interruptFn = interrupt) {
+    const decisionMode = resolveToolApprovalDecisionMode(compiledTool, binding);
+    if (decisionMode === "none" || typeof resolvedTool !== "object" || resolvedTool === null) {
         return resolvedTool;
     }
     const target = resolvedTool;
     const runWithApproval = async (input, config, invokeOriginal) => {
+        if (decisionMode === "auto-approve") {
+            return invokeOriginal(input, config);
+        }
+        if (decisionMode === "auto-reject" || decisionMode === "deny-and-continue") {
+            return "Tool execution denied by runtime policy.";
+        }
         const resumed = interruptFn({
             toolName: compiledTool.name,
             toolId: compiledTool.id,
             allowedDecisions: compiledTool.hitl?.allow ?? ["approve", "edit", "reject"],
             inputPreview: toInputPreview(input),
+            decisionMode,
             ...(toolApprovalReason(compiledTool) ? { approvalReason: toolApprovalReason(compiledTool) } : {}),
         });
         const approvedInput = resolveApprovedInput(input, resumed);
@@ -238,5 +307,5 @@ export function wrapToolForExecution(resolvedTool, compiledTool, binding, interr
             },
         })
         : resolvedTool;
-    return wrapToolWithDedupe(wrapToolForHumanInTheLoop(guardedTool, compiledTool, interruptFn), compiledTool);
+    return wrapToolWithDedupe(wrapToolForHumanInTheLoop(guardedTool, compiledTool, binding, interruptFn), compiledTool);
 }

package/dist/runtime/harness/events/listener-runtime.d.ts

@@ -4,10 +4,10 @@ export declare function createListenerDispatchRuntime(input: {
     notifyListener: <T>(listener: ((value: T) => void | Promise<void>) | undefined, value: T) => Promise<void>;
     getThread: (threadId: string) => Promise<{
         currentState: RunResult["state"];
-        latestRunId: string;
+        latestRequestId: string;
         entryAgentId: string;
         currentAgentId?: string;
-        runs: Array<{
+        requests: Array<{
             agentId: string;
         }>;
         pendingDecision?: {

package/dist/runtime/harness/events/streaming.d.ts

@@ -1,20 +1,20 @@
 import type { HarnessEvent, HarnessStreamItem, RunListeners, RunResult } from "../../../contracts/types.js";
 export type InternalHarnessStreamItem = HarnessStreamItem | {
     type: "content";
-    threadId: string;
-    runId: string;
+    sessionId: string;
+    requestId: string;
     agentId: string;
     content: string;
 } | {
     type: "content-blocks";
-    threadId: string;
-    runId: string;
+    sessionId: string;
+    requestId: string;
     agentId: string;
     contentBlocks: unknown[];
 } | {
     type: "tool-result";
-    threadId: string;
-    runId: string;
+    sessionId: string;
+    requestId: string;
     agentId: string;
     toolName: string;
     output: unknown;
@@ -27,10 +27,10 @@ export declare function dispatchRunListeners(stream: AsyncGenerator<InternalHarn
     notifyListener: <T>(listener: ((value: T) => void | Promise<void>) | undefined, value: T) => Promise<void>;
     getThread: (threadId: string) => Promise<{
         currentState: RunResult["state"];
-        latestRunId: string;
+        latestRequestId: string;
         entryAgentId: string;
         currentAgentId?: string;
-        runs: Array<{
+        requests: Array<{
             agentId: string;
         }>;
         pendingDecision?: {

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

@@ -5,8 +5,8 @@ export async function emitOutputDeltaAndCreateItem(emit, threadId, runId, agentI
     });
     return {
         type: "content",
-        threadId,
-        runId,
+        sessionId: threadId,
+        requestId: runId,
         agentId,
         content,
     };
@@ -14,8 +14,8 @@ export async function emitOutputDeltaAndCreateItem(emit, threadId, runId, agentI
 export function createContentBlocksItem(threadId, runId, agentId, contentBlocks) {
     return {
         type: "content-blocks",
-        threadId,
-        runId,
+        sessionId: threadId,
+        requestId: runId,
         agentId,
         contentBlocks,
     };
@@ -44,8 +44,8 @@ export async function dispatchRunListeners(stream, listeners, options) {
             await options.notifyListener(listeners.onUpstreamEvent, item.event);
             if (item.surfaceItem) {
                 await options.notifyListener(listeners.onTraceItem, {
-                    threadId: item.threadId,
-                    runId: item.runId,
+                    sessionId: item.sessionId,
+                    requestId: item.requestId,
                     surfaceItem: item.surfaceItem,
                     event: item.event,
                 });
@@ -67,16 +67,16 @@ export async function dispatchRunListeners(stream, listeners, options) {
     if (latestResult) {
         return mergeRunResultOutput(latestResult, output);
     }
-    const thread = await options.getThread(latestEvent.threadId);
+    const thread = await options.getThread(latestEvent.sessionId);
     if (!thread) {
-        throw new Error(`Unknown thread ${latestEvent.threadId}`);
+        throw new Error(`Unknown session ${latestEvent.sessionId}`);
     }
     return createFallbackRunResultFromLatestEvent({
         latestEvent,
         currentState: thread.currentState,
-        latestRunId: thread.latestRunId,
+        latestRunId: thread.latestRequestId,
         entryAgentId: thread.entryAgentId,
-        latestAgentId: thread.currentAgentId ?? thread.runs[0]?.agentId,
+        latestAgentId: thread.currentAgentId ?? thread.requests[0]?.agentId,
         approvalId: thread.pendingDecision?.approvalId,
         pendingActionId: thread.pendingDecision?.pendingActionId,
         output,

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

@@ -19,10 +19,10 @@ function classifyTimelineItem(event) {
 }
 export function projectRuntimeTimeline(events, options = {}) {
     const filtered = events.filter((event) => {
-        if (options.threadId && event.threadId !== options.threadId) {
+        if (options.sessionId && event.sessionId !== options.sessionId) {
             return false;
         }
-        if (options.runId && event.runId !== options.runId) {
+        if (options.requestId && event.requestId !== options.requestId) {
             return false;
         }
         return true;
@@ -40,8 +40,8 @@ export function projectRuntimeTimeline(events, options = {}) {
     })
         .map((event) => ({
         eventId: event.eventId,
-        threadId: event.threadId,
-        runId: event.runId,
+        sessionId: event.sessionId,
+        requestId: event.requestId,
         eventType: event.eventType,
         timestamp: event.timestamp,
         sequence: event.sequence,

package/dist/runtime/harness/run/governance.js

@@ -1,5 +1,5 @@
 import { getBindingPrimaryTools } from "../../support/compiled-binding.js";
-import { toolRequiresRuntimeApproval } from "../../adapter/tool/tool-hitl.js";
+import { resolveToolApprovalDecisionMode } from "../../adapter/tool/tool-hitl.js";
 import { compiledToolHasInputSchema } from "../tool-schema.js";
 const WRITE_LIKE_PATTERN = /\b(write|edit|delete|create|update|append|insert|push|commit|publish|send|post|apply|merge|sync|upload|save)\b/i;
 function inputHints(binding, tool) {
@@ -64,6 +64,11 @@ function readRisk(value) {
 function readApprovalPolicy(value) {
     return value === "explicit-hitl" || value === "runtime-default" || value === "none" ? value : undefined;
 }
+function readDecisionMode(value) {
+    return value === "none" || value === "manual" || value === "auto-approve" || value === "auto-reject" || value === "deny-and-continue"
+        ? value
+        : undefined;
+}
 function normalizeServerRef(value) {
     if (typeof value !== "string" || value.trim().length === 0) {
         return undefined;
@@ -123,18 +128,32 @@ function applyGovernanceOverrides(binding, policies) {
             const overrideRisk = readRisk(typedRule.risk);
             const overrideApprovalPolicy = readApprovalPolicy(typedRule.approvalPolicy);
             const overrideRequiresApproval = typeof typedRule.requiresApproval === "boolean" ? typedRule.requiresApproval : undefined;
+            const overrideDecisionMode = readDecisionMode(typedRule.decisionMode ?? typedRule.approvalMode);
             if (overrideRisk) {
                 merged.risk = overrideRisk;
             }
             if (overrideRequiresApproval !== undefined) {
                 merged.requiresApproval = overrideRequiresApproval;
             }
+            if (overrideDecisionMode) {
+                merged.decisionMode = overrideDecisionMode;
+                merged.requiresApproval = overrideDecisionMode === "manual";
+                merged.approvalPolicy =
+                    overrideDecisionMode === "none"
+                        ? "none"
+                        : merged.approvalPolicy === "explicit-hitl"
+                            ? "explicit-hitl"
+                            : "runtime-default";
+            }
             if (overrideApprovalPolicy) {
                 merged.approvalPolicy = overrideApprovalPolicy;
             }
             else if (overrideRequiresApproval === true && merged.approvalPolicy === "none") {
                 merged.approvalPolicy = "runtime-default";
             }
+            else if (overrideRequiresApproval === false && !overrideDecisionMode) {
+                merged.approvalPolicy = "none";
+            }
             const extraHints = readStringArray(typedRule.inputRiskHints);
             if (extraHints.length > 0) {
                 merged.inputRiskHints = Array.from(new Set([...merged.inputRiskHints, ...extraHints]));
@@ -160,6 +179,9 @@ function applyRemoteMcpGovernance(binding, policies) {
         const transport = merged.mcpTransport;
         if (transport && requireApprovalTransports.has(transport)) {
             merged.requiresApproval = true;
+            if (merged.decisionMode === "none") {
+                merged.decisionMode = "manual";
+            }
             if (merged.approvalPolicy === "none") {
                 merged.approvalPolicy = "runtime-default";
             }
@@ -179,11 +201,15 @@ export function buildRuntimeGovernanceBundles(binding) {
     const toolPolicies = applyGovernanceOverrides(binding, applyRemoteMcpGovernance(binding, getBindingPrimaryTools(binding).map((tool) => {
         const remoteMcp = readRemoteMcpMetadata(tool);
         const writeLikeRemoteMcp = tool.type === "mcp" && (remoteMcp.access === "read-write" || WRITE_LIKE_PATTERN.test(`${tool.name} ${tool.description}`));
-        const requiresApproval = toolRequiresRuntimeApproval(tool) ||
+        const derivedDecisionMode = resolveToolApprovalDecisionMode(tool, binding);
+        const requiresApproval = derivedDecisionMode === "manual" ||
             remoteMcp.trustTier === "untrusted" ||
             remoteMcp.approvalPolicy === "always" ||
             (remoteMcp.approvalPolicy === "write" && writeLikeRemoteMcp) ||
             remoteMcp.tenantScope === "cross-tenant";
+        const decisionMode = requiresApproval
+            ? (derivedDecisionMode === "none" ? "manual" : derivedDecisionMode)
+            : derivedDecisionMode;
         const approvalReason = remoteMcp.trustTier === "untrusted"
             ? "untrusted-mcp-server"
             : remoteMcp.tenantScope === "cross-tenant"
@@ -230,7 +256,8 @@ export function buildRuntimeGovernanceBundles(binding) {
                 promptInjectionRisk: remoteMcp.promptInjectionRisk,
             }),
             requiresApproval,
-            approvalPolicy: tool.hitl?.enabled === true ? "explicit-hitl" : requiresApproval ? "runtime-default" : "none",
+            approvalPolicy: tool.hitl?.enabled === true ? "explicit-hitl" : decisionMode === "none" ? "none" : "runtime-default",
+            decisionMode,
             hasInputSchema: compiledToolHasInputSchema(tool),
             inputRiskHints: Array.from(new Set(inputRiskHints)),
         };
@@ -241,7 +268,9 @@ export function buildRuntimeGovernanceBundles(binding) {
     return [{
             bundleId: `governance/${binding.agent.id}`,
             title: "Runtime tool governance",
-            summary: `${toolPolicies.filter((tool) => tool.requiresApproval).length} of ${toolPolicies.length} tool(s) require approval`,
+            summary: `${toolPolicies.filter((tool) => tool.requiresApproval).length} of ${toolPolicies.length} tool(s) require approval; ` +
+                `auto-approved=${toolPolicies.filter((tool) => tool.decisionMode === "auto-approve").length}; ` +
+                `auto-rejected=${toolPolicies.filter((tool) => tool.decisionMode === "auto-reject" || tool.decisionMode === "deny-and-continue").length}`,
             toolPolicies,
         }];
 }

package/dist/runtime/harness/run/helpers.js

@@ -57,8 +57,8 @@ export function mergeRunResultOutput(result, streamedOutput) {
 }
 export function createFallbackRunResultFromLatestEvent(input) {
     return {
-        threadId: input.latestEvent.threadId,
-        runId: input.latestRunId,
+        sessionId: input.latestEvent.sessionId,
+        requestId: input.latestRunId,
         agentId: input.latestAgentId ?? input.entryAgentId,
         state: input.currentState,
         output: input.output,