@botbotgo/agent-harness 0.0.267 → 0.0.269

package/dist/runtime/harness.js

@@ -51,6 +51,70 @@ const ACTIVE_RUN_STATES = [
     "resuming",
     "cancelling",
 ];
+function toPublicRunResultShape(result) {
+    return {
+        sessionId: result.sessionId ?? result.threadId ?? "",
+        requestId: result.requestId ?? result.runId ?? "",
+        state: result.state,
+        output: result.output,
+        finalMessageText: result.finalMessageText,
+        outputContent: result.outputContent,
+        contentBlocks: result.contentBlocks,
+        structuredResponse: result.structuredResponse,
+        interruptContent: result.interruptContent,
+        agentId: result.agentId,
+        approvalId: result.approvalId,
+        pendingActionId: result.pendingActionId,
+        delegationId: result.delegationId,
+        artifacts: result.artifacts,
+        metadata: result.metadata,
+    };
+}
+function toPublicHarnessStreamItem(item) {
+    switch (item.type) {
+        case "content":
+            return {
+                type: "content",
+                sessionId: item.sessionId,
+                requestId: item.requestId,
+                agentId: item.agentId,
+                content: item.content,
+            };
+        case "content-blocks":
+            return {
+                type: "content-blocks",
+                sessionId: item.sessionId,
+                requestId: item.requestId,
+                agentId: item.agentId,
+                contentBlocks: item.contentBlocks,
+            };
+        case "tool-result":
+            return {
+                type: "tool-result",
+                sessionId: item.sessionId,
+                requestId: item.requestId,
+                agentId: item.agentId,
+                toolName: item.toolName,
+                output: item.output,
+                ...(item.isError !== undefined ? { isError: item.isError } : {}),
+            };
+        case "upstream-event":
+            return {
+                type: "upstream-event",
+                sessionId: item.sessionId,
+                requestId: item.requestId,
+                ...(item.surfaceItem ? { surfaceItem: item.surfaceItem } : {}),
+                event: item.event,
+            };
+        case "result":
+            return {
+                type: "result",
+                result: toPublicRunResultShape(item.result),
+            };
+        default:
+            return item;
+    }
+}
 function normalizeSessionListText(content, limit) {
     if (!content) {
         return undefined;
@@ -66,8 +130,8 @@ function toSessionListSummary(session) {
     return {
         agentId: session.agentId,
         entryAgentId: session.entryAgentId,
-        sessionId: session.threadId,
-        latestRequestId: session.latestRunId,
+        sessionId: session.sessionId,
+        latestRequestId: session.latestRequestId,
         createdAt: session.createdAt,
         updatedAt: session.updatedAt,
         status: session.status,
@@ -363,8 +427,8 @@ export class AgentHarnessRuntime {
         const sessions = await this.persistence.listSessions(filter);
         return sessions.map((session) => ({
             agentId: session.agentId,
-            sessionId: session.threadId,
-            latestRequestId: session.latestRunId,
+            sessionId: session.sessionId,
+            latestRequestId: session.latestRequestId,
             createdAt: session.createdAt,
             updatedAt: session.updatedAt,
             status: session.status,
@@ -376,16 +440,7 @@ export class AgentHarnessRuntime {
         return sessions.map((session) => toSessionListSummary(session));
     }
     async listThreads(filter) {
-        const sessions = await this.listSessions(filter);
-        return sessions.map((session) => ({
-            agentId: session.agentId,
-            threadId: session.sessionId,
-            latestRunId: session.latestRequestId,
-            createdAt: session.createdAt,
-            updatedAt: session.updatedAt,
-            status: session.status,
-            currentAgentId: session.currentAgentId,
-        }));
+        return this.listSessions(filter);
     }
     async listRequests(filter) {
         const requests = await this.persistence.listRuns({
@@ -394,8 +449,8 @@ export class AgentHarnessRuntime {
             state: filter?.state,
         });
         return requests.map((request) => ({
-            requestId: request.runId,
-            sessionId: request.threadId,
+            requestId: request.requestId,
+            sessionId: request.sessionId,
             agentId: request.agentId,
             parentRunId: request.parentRunId,
             executionMode: request.executionMode,
@@ -414,30 +469,11 @@ export class AgentHarnessRuntime {
         }));
     }
     async listRuns(filter) {
-        const requests = await this.listRequests({
+        return this.listRequests({
             agentId: filter?.agentId,
             sessionId: filter?.threadId,
             state: filter?.state,
         });
-        return requests.map((request) => ({
-            runId: request.requestId,
-            threadId: request.sessionId,
-            agentId: request.agentId,
-            parentRunId: request.parentRunId,
-            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,
-        }));
     }
     async memorize(input) {
         const binding = this.defaultRuntimeEntryBinding;
@@ -456,10 +492,10 @@ export class AgentHarnessRuntime {
         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.");
         }
-        const sessionId = input.sessionId ?? input.threadId;
-        const requestId = input.requestId ?? input.runId;
+        const sessionId = input.sessionId;
+        const requestId = input.requestId;
         if (candidates.some((record) => (record.scope ?? "thread") === "thread") && !sessionId) {
-            throw new Error("memorize requires sessionId (or legacy threadId) when storing thread-scoped memory.");
+            throw new Error("memorize requires sessionId when storing thread-scoped memory.");
         }
         const recordedAt = input.recordedAt ?? new Date().toISOString();
         const runId = requestId ?? createPersistentId(new Date(recordedAt));
@@ -483,7 +519,7 @@ export class AgentHarnessRuntime {
         if (typeof input.query !== "string" || input.query.trim().length === 0) {
             throw new Error("recall requires a non-empty query.");
         }
-        const sessionId = input.sessionId ?? input.threadId;
+        const sessionId = input.sessionId;
         const workspaceId = this.getWorkspaceId(binding);
         const agentId = input.agentId ?? binding.agent.id;
         const userId = input.userId ?? "default";
@@ -516,7 +552,7 @@ export class AgentHarnessRuntime {
         if (!binding) {
             throw new Error("listMemories requires a runtime entry binding.");
         }
-        const sessionId = input.sessionId ?? input.threadId;
+        const sessionId = input.sessionId;
         const workspaceId = this.getWorkspaceId(binding);
         const scopes = Array.isArray(input.scopes) && input.scopes.length > 0
             ? Array.from(new Set(input.scopes))
@@ -609,37 +645,15 @@ export class AgentHarnessRuntime {
         return request ? buildRequestInspectionRecord(this.persistence, request) : null;
     }
     async getRun(runId) {
-        const request = await this.getRequest(runId);
-        return request
-            ? {
-                runId: request.requestId,
-                threadId: request.sessionId,
-                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,
-            }
-            : null;
+        return this.getRequest(runId);
     }
     async getSessionSummary(sessionId) {
         const session = await this.persistence.getSession(sessionId);
         return session
             ? {
                 agentId: session.agentId,
-                sessionId: session.threadId,
-                latestRequestId: session.latestRunId,
+                sessionId: session.sessionId,
+                latestRequestId: session.latestRequestId,
                 createdAt: session.createdAt,
                 updatedAt: session.updatedAt,
                 status: session.status,
@@ -648,18 +662,7 @@ export class AgentHarnessRuntime {
             : null;
     }
     async getSession(threadId) {
-        const session = await this.getSessionSummary(threadId);
-        return session
-            ? {
-                agentId: session.agentId,
-                threadId: session.sessionId,
-                latestRunId: session.latestRequestId,
-                createdAt: session.createdAt,
-                updatedAt: session.updatedAt,
-                status: session.status,
-                currentAgentId: session.currentAgentId,
-            }
-            : null;
+        return this.getSessionSummary(threadId);
     }
     async getSessionRecord(sessionId) {
         return buildSessionInspectionRecord({
@@ -668,45 +671,17 @@ export class AgentHarnessRuntime {
         }, sessionId);
     }
     async getThread(threadId) {
-        const session = await this.getSessionRecord(threadId);
-        return session
-            ? {
-                threadId: session.sessionId,
-                entryAgentId: session.entryAgentId,
-                currentAgentId: session.currentAgentId,
-                currentState: session.currentState,
-                latestRunId: session.latestRequestId,
-                createdAt: session.createdAt,
-                updatedAt: session.updatedAt,
-                messages: session.messages,
-                runs: session.requests.map((request) => ({
-                    runId: request.requestId,
-                    threadId: request.sessionId,
-                    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,
-                })),
-                pendingDecision: session.pendingDecision,
-            }
-            : null;
+        return this.getSessionRecord(threadId);
     }
     async listApprovals(filter) {
-        return listPublicApprovals({
+        const approvals = await listPublicApprovals({
             persistence: this.persistence,
-        }, filter);
+        }, {
+            status: filter?.status,
+            threadId: filter?.sessionId,
+            runId: filter?.requestId,
+        });
+        return approvals;
     }
     async getApproval(approvalId) {
         return getPublicApproval({
@@ -714,7 +689,12 @@ export class AgentHarnessRuntime {
         }, approvalId);
     }
     async listArtifacts(threadId, runId) {
-        return this.persistence.listArtifacts(threadId, runId);
+        const listing = await this.persistence.listArtifacts(threadId, runId);
+        return {
+            sessionId: listing.sessionId,
+            requestId: listing.requestId,
+            items: listing.items,
+        };
     }
     async readArtifact(threadId, runId, artifactPath) {
         return this.persistence.readArtifact(threadId, runId, artifactPath);
@@ -728,7 +708,7 @@ export class AgentHarnessRuntime {
     async exportRequestPackage(input) {
         const session = await this.getSessionRecord(input.sessionId);
         const request = await this.getRequest(input.requestId);
-        const approvals = await this.listApprovals({ threadId: input.sessionId, runId: input.requestId });
+        const approvals = await this.listApprovals({ sessionId: input.sessionId, requestId: input.requestId });
         const transcript = await this.persistence.listThreadMessages(input.sessionId, 500);
         const events = await this.listRequestEvents(input.sessionId, input.requestId);
         const artifactsListing = input.includeArtifacts === false
@@ -777,7 +757,7 @@ export class AgentHarnessRuntime {
             includeArtifactContents: input.includeArtifactContents,
             includeRuntimeHealth: false,
         })));
-        const approvals = await this.listApprovals({ threadId: input.sessionId });
+        const approvals = await this.listApprovals({ sessionId: input.sessionId });
         const approvalSummary = summarizeApprovalEvidence(approvals);
         const governanceRuns = runs
             .filter((item) => item.request?.requestId)
@@ -803,7 +783,7 @@ export class AgentHarnessRuntime {
         const thread = await this.getThread(input.sessionId);
         const run = await this.getRun(input.requestId);
         const runRequest = await this.persistence.getRunRequest(input.sessionId, input.requestId);
-        const approvals = await this.listApprovals({ threadId: input.sessionId, runId: input.requestId });
+        const approvals = await this.listApprovals({ sessionId: input.sessionId, requestId: input.requestId });
         const transcript = await this.persistence.listThreadMessages(input.sessionId, 500);
         const events = await this.persistence.listRunEvents(input.sessionId, input.requestId);
         const runtimeHealth = await this.getHealth();
@@ -979,11 +959,11 @@ export class AgentHarnessRuntime {
     }
     async loadPriorHistory(threadId, runId) {
         const history = await this.persistence.listThreadMessages(threadId);
-        return history.filter((message) => message.runId !== runId);
+        return history.filter((message) => message.requestId !== runId);
     }
     async loadRunInput(threadId, runId) {
         const history = await this.persistence.listThreadMessages(threadId, 100);
-        const userTurn = history.find((message) => message.runId === runId && message.role === "user");
+        const userTurn = history.find((message) => message.requestId === runId && message.role === "user");
         return userTurn?.content ?? "";
     }
     async getRunCancellation(runId) {
@@ -1037,7 +1017,8 @@ export class AgentHarnessRuntime {
         return (content.trim().split("\n")[0] || content.trim()).slice(0, 240);
     }
     matchesMemoryFilters(record, filters) {
-        if (filters.threadId && record.provenance.threadId !== filters.threadId) {
+        const sessionId = String(record.provenance.sessionId ?? record.provenance.threadId ?? "");
+        if (filters.threadId && sessionId !== filters.threadId) {
             return false;
         }
         if (filters.agentId && record.provenance.agentId !== filters.agentId) {
@@ -1069,7 +1050,8 @@ export class AgentHarnessRuntime {
     }
     matchesRecallScope(record, filters) {
         if (record.scope === "thread") {
-            return typeof filters.threadId === "string" && String(record.provenance.threadId ?? "") === filters.threadId;
+            return typeof filters.threadId === "string"
+                && String(record.provenance.sessionId ?? record.provenance.threadId ?? "") === filters.threadId;
         }
         if (record.scope === "agent") {
             return String(record.provenance.agentId ?? "") === filters.agentId;
@@ -1153,8 +1135,16 @@ export class AgentHarnessRuntime {
             tags: hit.categories,
             provenance: {
                 source: "mem0",
-                threadId: typeof hit.metadata.threadId === "string" ? hit.metadata.threadId : filters.threadId,
-                runId: hit.runId ?? (typeof hit.metadata.runId === "string" ? hit.metadata.runId : undefined),
+                sessionId: typeof hit.metadata.sessionId === "string"
+                    ? hit.metadata.sessionId
+                    : typeof hit.metadata.threadId === "string"
+                        ? hit.metadata.threadId
+                        : filters.threadId,
+                requestId: (typeof hit.metadata.requestId === "string"
+                    ? hit.metadata.requestId
+                    : typeof hit.metadata.runId === "string"
+                        ? hit.metadata.runId
+                        : undefined),
                 agentId: hit.agentId ?? (typeof hit.metadata.agentId === "string" ? hit.metadata.agentId : filters.agentId),
                 workspaceId: filters.workspaceId,
                 userId: filters.userId,
@@ -1271,7 +1261,7 @@ export class AgentHarnessRuntime {
                     scope: record.scope,
                     kind: record.kind,
                     status: record.status,
-                    threadId: record.provenance.threadId,
+                    sessionId: record.provenance.sessionId ?? record.provenance.threadId,
                     agentId: record.provenance.agentId,
                     workspaceId: record.provenance.workspaceId,
                     userId: record.provenance.userId,
@@ -1298,7 +1288,7 @@ export class AgentHarnessRuntime {
         await consolidateStructuredMemoryScope({
             store: this.runtimeMemoryStore,
             namespace: this.resolveMemoryNamespace(record.scope, binding, {
-                threadId: provenance.threadId,
+                threadId: provenance.sessionId,
                 agentId: provenance.agentId,
                 userId: provenance.userId,
                 projectId: provenance.projectId,
@@ -1594,8 +1584,8 @@ export class AgentHarnessRuntime {
     async run(options) {
         if (this.isDecisionRun(options)) {
             const resumeOptions = {
-                threadId: options.threadId,
-                runId: options.runId,
+                sessionId: options.sessionId,
+                requestId: options.requestId,
                 approvalId: options.approvalId,
                 decision: options.decision,
                 editedInput: options.editedInput,
@@ -1604,10 +1594,23 @@ export class AgentHarnessRuntime {
         }
         const resolvedListeners = resolveRunListeners(options);
         if (resolvedListeners) {
-            return createListenerDispatchRuntime({
+            const result = await createListenerDispatchRuntime({
                 notifyListener: (listener, value) => this.notifyListener(listener, value),
-                getThread: (threadId) => this.getThread(threadId),
+                getThread: async (threadId) => {
+                    const thread = await this.getThread(threadId);
+                    return thread
+                        ? {
+                            currentState: thread.currentState,
+                            latestRequestId: thread.latestRequestId,
+                            entryAgentId: thread.entryAgentId,
+                            currentAgentId: thread.currentAgentId,
+                            requests: thread.requests.map((run) => ({ agentId: run.agentId })),
+                            pendingDecision: thread.pendingDecision,
+                        }
+                        : null;
+                },
             }).dispatchRunListeners(this.streamEvents(options), resolvedListeners);
+            return toPublicRunResultShape(result);
         }
         const invocation = normalizeInvocationEnvelope(options);
         const { binding, selectedAgentId, threadId, runId, isNewThread, runCreatedEventPromise, releaseRunSlotPromise, } = await prepareRunStart(this.createPrepareRunStartRuntime(), {
@@ -1623,7 +1626,7 @@ export class AgentHarnessRuntime {
         await runCreatedEventPromise;
         const releaseRunSlot = await releaseRunSlotPromise;
         try {
-            return await this.executeQueuedRun(binding, options.input, threadId, runId, selectedAgentId, {
+            return toPublicRunResultShape(await this.executeQueuedRun(binding, options.input, threadId, runId, selectedAgentId, {
                 context: invocation.context,
                 state: invocation.state,
                 files: invocation.files,
@@ -1631,7 +1634,7 @@ export class AgentHarnessRuntime {
                 stateSequence: 6,
                 approvalSequence: 7,
                 priorHistory: isNewThread ? [] : undefined,
-            });
+            }));
         }
         finally {
             await releaseRunSlot();
@@ -1639,7 +1642,7 @@ export class AgentHarnessRuntime {
     }
     async *streamEvents(options) {
         const invocation = normalizeInvocationEnvelope(options);
-        const selectedAgentId = await this.resolveSelectedAgentId(options.input, options.agentId, options.threadId);
+        const selectedAgentId = await this.resolveSelectedAgentId(options.input, options.agentId, options.sessionId);
         const binding = getWorkspaceBinding(this.workspace, selectedAgentId);
         if (!binding) {
             const result = await this.run(options);
@@ -1687,11 +1690,11 @@ export class AgentHarnessRuntime {
             emitSyntheticFallback: (threadId, runId, selectedAgentId, error) => this.runtimeEventOperations.emitSyntheticFallback(threadId, runId, selectedAgentId, error),
         });
         for await (const item of stream) {
-            yield item;
+            yield toPublicHarnessStreamItem(item);
         }
     }
     async resume(options) {
-        return resumeRun({
+        return toPublicRunResultShape(await resumeRun({
             getApprovalById: (approvalId) => this.persistence.getApproval(approvalId),
             getSession: (threadId) => this.getSession(threadId),
             resolveApprovalRecord: (resumeOptions, thread) => resolveHarnessApprovalRecord(this.persistence, resumeOptions, thread),
@@ -1712,30 +1715,32 @@ export class AgentHarnessRuntime {
             recordLlmFailure: (startedAt) => this.recordLlmFailure(startedAt),
             clearRecoveryIntent: (threadId, runId) => this.persistence.clearRecoveryIntent(threadId, runId),
             finalizeContinuedRun: (binding, threadId, runId, input, actual, operationOptions) => this.finalizeContinuedRun(binding, threadId, runId, input, actual, operationOptions),
-        }, options);
+        }, {
+            ...options,
+        }));
     }
     async restartConversation(options) {
-        const thread = await this.getSession(options.threadId);
-        if (!thread) {
-            throw new Error(`Unknown thread ${options.threadId}`);
+        const session = await this.getSession(options.sessionId);
+        if (!session) {
+            throw new Error(`Unknown session ${options.sessionId}`);
         }
-        const sourceRunId = thread.latestRunId;
-        const targetThreadId = options.mode === "restart-new-thread" ? createPersistentId() : options.threadId;
+        const sourceRequestId = session.latestRequestId;
+        const targetSessionId = options.mode === "restart-new-thread" ? createPersistentId() : options.sessionId;
         const result = await this.run({
-            agentId: thread.agentId,
+            agentId: session.agentId,
             input: options.input,
-            threadId: options.mode === "restart-new-thread" ? undefined : targetThreadId,
+            sessionId: options.mode === "restart-new-thread" ? undefined : targetSessionId,
         });
         return {
             ...result,
             restart: {
-                sourceThreadId: options.threadId,
-                sourceRunId,
+                sourceSessionId: options.sessionId,
+                sourceRequestId,
                 restartMode: options.mode,
                 restartedBy: "console",
                 restartedAt: new Date().toISOString(),
-                newThreadId: result.threadId,
-                newRunId: result.runId,
+                newSessionId: result.sessionId,
+                newRequestId: result.requestId,
             },
         };
     }
@@ -1761,13 +1766,13 @@ export class AgentHarnessRuntime {
         await this.close();
     }
     async cancelRun(options) {
-        return cancelRunOperation({
+        return toPublicRunResultShape(await cancelRunOperation({
             getRun: (runId) => this.persistence.getRun(runId),
             requestRunCancel: (runId, reason) => this.persistence.requestRunCancel(runId, reason),
             dropPendingRunSlot: (runId) => this.dropPendingRunSlot(runId),
             finalizeCancelledRun: (threadId, runId, previousState, reason) => this.finalizeCancelledRun(threadId, runId, previousState, reason),
             setRunStateAndEmit: (threadId, runId, sequence, state, stateOptions) => this.setRunStateAndEmit(threadId, runId, sequence, state, stateOptions),
-        }, options);
+        }, options));
     }
     async recoverStartupRuns() {
         await recoverHarnessStartupRuns({
@@ -1812,8 +1817,8 @@ export class AgentHarnessRuntime {
 }
 function toRequestSummary(summary) {
     return {
-        requestId: summary.runId,
-        sessionId: summary.threadId,
+        requestId: summary.requestId,
+        sessionId: summary.sessionId,
         agentId: summary.agentId,
         parentRunId: summary.parentRunId,
         executionMode: summary.executionMode,
@@ -1833,15 +1838,15 @@ function toRequestSummary(summary) {
 }
 function toSessionRecord(record) {
     return {
-        sessionId: record.threadId,
+        sessionId: record.sessionId,
         entryAgentId: record.entryAgentId,
         currentAgentId: record.currentAgentId,
         currentState: record.currentState,
-        latestRequestId: record.latestRunId,
+        latestRequestId: record.latestRequestId,
         createdAt: record.createdAt,
         updatedAt: record.updatedAt,
         messages: record.messages,
-        requests: record.runs.map(toRequestRecord),
+        requests: record.requests.map(toRequestRecord),
         pendingDecision: record.pendingDecision,
     };
 }
@@ -1852,9 +1857,9 @@ function toRequestRecord(record) {
         runtimeTimeline: record.runtimeTimeline,
     };
 }
-function deriveRunRequestFromTranscript(transcript, runId) {
+function deriveRunRequestFromTranscript(transcript, requestId) {
     const candidate = [...transcript]
         .reverse()
-        .find((message) => message.role === "user" && (!runId || message.runId === runId));
+        .find((message) => message.role === "user" && (!requestId || message.requestId === requestId));
     return candidate ? { input: candidate.content } : null;
 }

package/dist/runtime/support/harness-support.js

@@ -59,8 +59,8 @@ export function createHarnessEvent(threadId, runId, sequence, eventType, payload
         eventId: `evt-${String(sequence).padStart(6, "0")}`,
         eventType,
         timestamp: new Date().toISOString(),
-        threadId,
-        runId,
+        sessionId: threadId,
+        requestId: runId,
         sequence,
         source,
         payload,
@@ -73,8 +73,8 @@ export function createPendingApproval(threadId, runId, checkpointRef, input, int
     return {
         approvalId,
         pendingActionId: approvalId,
-        threadId,
-        runId,
+        sessionId: threadId,
+        requestId: runId,
         toolCallId: interrupt.toolId ?? `tool-${runId}`,
         toolName: interrupt.toolName ?? "write_file",
         status: "pending",

package/dist/workspace/compile.js

@@ -10,7 +10,7 @@ import { validateAgent, validateTopology } from "./validate.js";
 import { compileBinding } from "./agent-binding-compiler.js";
 import { discoverSubagents, ensureDiscoverySources } from "./support/discovery.js";
 import { collectAgentDiscoverySourceRefs, collectToolSourceRefs } from "./support/source-collectors.js";
-import { getRoutingDefaultAgentId, getRuntimeResources, getRoutingRules, resolveRefId, } from "./support/workspace-ref-utils.js";
+import { getRoutingDefaultAgentId, getRuntimeResources, getToolModuleDiscoveryConfig, getRoutingRules, resolveRefId, } from "./support/workspace-ref-utils.js";
 import { hydrateAgentMcpTools, hydrateResourceAndExternalTools } from "./tool-hydration.js";
 import { traceStartupStage } from "../runtime/startup-tracing.js";
 import { shouldSkipScanDirectory } from "../utils/fs.js";
@@ -123,7 +123,7 @@ async function resolveConfiguredResources(entries, workspaceRoot) {
     }
     return resolved;
 }
-async function registerAttachedResourceTools(tools, resourceRoot) {
+async function registerAttachedResourceTools(tools, resourceRoot, toolModuleDiscoveryScope) {
     const toolsRoot = path.join(resourceRoot, "tools");
     for (const { item, sourcePath } of await readYamlItems(toolsRoot, undefined, { recursive: true })) {
         const parsed = parseToolObject({
@@ -134,7 +134,7 @@ async function registerAttachedResourceTools(tools, resourceRoot) {
         });
         tools.set(parsed.id, parsed);
     }
-    for (const { item, sourcePath } of await readToolModuleItems(toolsRoot)) {
+    for (const { item, sourcePath } of await readToolModuleItems(toolsRoot, { scope: toolModuleDiscoveryScope })) {
         const parsed = parseToolObject({
             id: String(item.id),
             kind: "tool",
@@ -221,6 +221,7 @@ export async function loadWorkspace(workspaceRoot, options = {}) {
         loaded.refs.set(`agent/${agent.id}`, agent);
     }
     const { embeddings, mcpServers, models, vectorStores, tools } = collectParsedResources(loaded.refs);
+    const toolModuleDiscoveryConfig = getToolModuleDiscoveryConfig(loaded.refs);
     await traceStartupStage("workspace.hydrate.agentMcpTools", () => hydrateAgentMcpTools(loaded.agents, mcpServers, tools), {
         workspaceRoot,
         agentCount: loaded.agents.length,
@@ -234,7 +235,7 @@ export async function loadWorkspace(workspaceRoot, options = {}) {
         configuredResourceCount: configuredResources.length,
     });
     for (const resource of resolvedConfiguredResources) {
-        await traceStartupStage("workspace.register.attachedResourceTools", () => registerAttachedResourceTools(tools, resource.root), {
+        await traceStartupStage("workspace.register.attachedResourceTools", () => registerAttachedResourceTools(tools, resource.root, toolModuleDiscoveryConfig.scope), {
             workspaceRoot,
             resourceRoot: resource.root,
         });
@@ -259,7 +260,7 @@ export async function loadWorkspace(workspaceRoot, options = {}) {
         workspaceRoot,
         externalResourceCount: externalResources.length,
     });
-    await traceStartupStage("workspace.hydrate.externalTools", () => hydrateResourceAndExternalTools(tools, externalResources, workspaceRoot), {
+    await traceStartupStage("workspace.hydrate.externalTools", () => hydrateResourceAndExternalTools(tools, externalResources, workspaceRoot, toolModuleDiscoveryConfig.scope), {
         workspaceRoot,
         externalResourceCount: externalResources.length,
     });