@pasko70/pibo 2.4.1 → 2.4.3

package/dist/agent-runtime/context-build.js

@@ -1,5 +1,11 @@
+import { createPiboRuntimeResolutionManifest, } from "../core/context-build.js";
 import { InitialSessionContext } from "../core/profiles.js";
 import { PIBO_AGENT_TOOL_NAMES, listAvailableAgents } from "../subagents/tool.js";
+import { PIBO_DELEGATED_AGENT_CONTEXT_PATH } from "../subagents/context.js";
+import { PIBO_RUN_TOOL_NAMES } from "../runs/tools.js";
+import { PIBO_GOAL_TOOL_NAMES } from "../loops/tools.js";
+import { CODEX_COMPAT_TOOL_NAMES } from "../tools/codex-compat.js";
+import { isEnabledRuntimeToolProfile, materializePiboProfileTools, } from "../tools/session-tool-set.js";
 export function profileWithRuntimeInstance(profile, runtimeInstanceId) {
     if (profile.runtimeInstanceId === runtimeInstanceId)
         return profile;
@@ -41,10 +47,100 @@ export function uniqueRuntimeDiagnostics(diagnostics) {
         return true;
     });
 }
+function uniqueNames(values) {
+    return [...new Set(values)];
+}
 export function buildPortableRuntimeContextSnapshot(input) {
     const profile = input.profile;
     const nodes = [];
     const addNode = (node) => nodes.push({ ...node, order: nodes.length });
+    const availableAgents = listAvailableAgents(profile.subagents);
+    const delegatedSendAvailable = availableAgents.length > 0;
+    const toolContext = {
+        piboSessionId: input.piboSessionId,
+        piboRoomId: input.piboRoomId,
+        profileName: profile.profileName,
+        cwd: input.cwd,
+    };
+    const materializedProfileTools = materializePiboProfileTools(profile, toolContext);
+    const runtimeProfileTool = profile.tools.find(isEnabledRuntimeToolProfile);
+    const callableProfileTools = [
+        ...materializedProfileTools.map((tool) => ({ name: tool.definition.name, yieldable: tool.profile.yieldable })),
+        ...(runtimeProfileTool ? [{ name: "runtime", yieldable: runtimeProfileTool.yieldable }] : []),
+    ];
+    const profileToolNames = callableProfileTools.map((tool) => tool.name);
+    const directAgentToolNames = delegatedSendAvailable
+        ? PIBO_AGENT_TOOL_NAMES.filter((name) => name !== "pibo_agents_send_message")
+        : [];
+    const codexCompatToolNames = profile.toolPackages.codexCompat === true ? [...CODEX_COMPAT_TOOL_NAMES] : [];
+    const explicitYieldableToolNames = uniqueNames([
+        ...callableProfileTools.filter((tool) => tool.yieldable !== false).map((tool) => tool.name),
+        ...(delegatedSendAvailable ? PIBO_AGENT_TOOL_NAMES : []),
+        ...codexCompatToolNames,
+    ]);
+    const yieldableToolNames = profile.toolPackages.runControl === true
+        ? explicitYieldableToolNames
+        : delegatedSendAvailable ? ["pibo_agents_send_message"] : [];
+    const runControlAvailable = yieldableToolNames.length > 0;
+    const activeToolNames = uniqueNames([
+        ...profileToolNames,
+        ...directAgentToolNames,
+        ...codexCompatToolNames,
+        ...(profile.toolPackages.goalControl !== false ? PIBO_GOAL_TOOL_NAMES : []),
+        ...(runControlAvailable ? PIBO_RUN_TOOL_NAMES : []),
+    ]);
+    const activeToolPackages = [
+        ...(profile.toolPackages.goalControl !== false ? ["pibo-goal-control"] : []),
+        ...(profile.toolPackages.codexCompat === true ? ["codex-compat"] : []),
+        ...(runControlAvailable ? ["pibo-run-control"] : []),
+    ];
+    const managedToolDisplayNames = [
+        ...activeToolNames,
+        ...yieldableToolNames.map((name) => `yielded-target:${name}`),
+        ...availableAgents.map((agent) => `agent:${agent.name} (${agent.profile}) — ${agent.description}`),
+        ...activeToolPackages.map((name) => name === "pibo-run-control" && profile.toolPackages.runControl !== true
+            ? "package:pibo-run-control (automatic for delegation)"
+            : `package:${name}`),
+    ];
+    const manifestContextPaths = input.resources
+        ? input.resources.context.flatMap((contribution) => {
+            const path = contribution.materializedPath ?? contribution.path ?? contribution.sourcePath;
+            return path ? [path] : [];
+        })
+        : [
+            "pibo://runtime/session-context.md",
+            ...profile.contextFiles.filter((file) => file.enabled !== false).map((file) => file.key ?? file.path),
+            ...(delegatedSendAvailable ? [PIBO_DELEGATED_AGENT_CONTEXT_PATH] : []),
+        ];
+    const runtimeManifest = createPiboRuntimeResolutionManifest({
+        profile,
+        cwd: input.cwd,
+        adapterId: input.runtime.adapterId,
+        piboSessionId: input.piboSessionId,
+        piboRoomId: input.piboRoomId,
+        activeModel: input.activeModel,
+        thinkingLevel: input.thinkingLevel,
+        toolSurface: "pibo-managed-only",
+        activeToolNames,
+        yieldableToolNames,
+        activeToolPackages,
+        contextFilePaths: manifestContextPaths,
+        skillNames: input.resources
+            ? input.resources.skills.map((skill) => skill.name)
+            : profile.skills.filter((skill) => skill.enabled !== false).map((skill) => skill.name),
+        modelDefaults: input.modelDefaults,
+        subagentProfileResolver: input.subagentProfileResolver,
+    });
+    addNode({
+        id: "runtime-manifest",
+        kind: "runtime_manifest",
+        title: "Runtime Resolution Manifest",
+        source: "runtime",
+        state: "active",
+        badges: ["RESOLVED", "READ-ONLY", "PIBO-MANAGED-TOOLS"],
+        payloadJson: runtimeManifest,
+        notes: ["Resolution evidence for this inspection only. It is not a second profile configuration and is not injected into the agent prompt. Harness-native tool names may remain discoverable only at runtime."],
+    });
     addNode({
         id: "runtime",
         kind: "metadata",
@@ -62,16 +158,9 @@ export function buildPortableRuntimeContextSnapshot(input) {
         },
         payloadJson: input.runtime.capabilities,
     });
-    const availableAgents = listAvailableAgents(profile.subagents);
-    addRuntimeContributionGroup(nodes, "tools", "Pibo Tools and Delegated Agents", [
-        ...profile.tools.filter((tool) => tool.enabled !== false).map((tool) => tool.name),
-        ...(availableAgents.length > 0 ? PIBO_AGENT_TOOL_NAMES : []),
-        ...availableAgents.map((agent) => `agent:${agent.name} (${agent.profile}) — ${agent.description}`),
-        ...(profile.toolPackages.goalControl !== false ? ["package:pibo-goal-control"] : []),
-        ...(profile.toolPackages.runControl === true ? ["package:pibo-run-control"] : []),
-    ], input.runtime.capabilities.tools.piboManaged);
+    addRuntimeContributionGroup(nodes, "tools", "Pibo Tools and Delegated Agents", managedToolDisplayNames, input.runtime.capabilities.tools.piboManaged);
     addNativeToolInspectionNode(nodes, input.runtime.capabilities.tools.nativeToolInspection);
-    if (profile.toolPackages.runControl === true) {
+    if (runControlAvailable) {
         addNativeToolYieldingNode(nodes, input.runtime.capabilities.tools.nativeToolYielding);
     }
     if (input.resources) {
@@ -138,7 +227,7 @@ export function buildPortableRuntimeContextSnapshot(input) {
         source: "profile",
         state: "active",
         metadata: {
-            activeModel: input.activeModel,
+            activeModel: runtimeManifest.effectiveModel,
             mainModel: profile.mainModel,
             subagentModel: profile.subagentModel,
             mainThinkingLevel: profile.mainThinkingLevel ?? profile.thinkingLevel,
@@ -187,7 +276,7 @@ export function buildPortableRuntimeContextSnapshot(input) {
         piboSessionId: input.piboSessionId,
         piboRoomId: input.piboRoomId,
         cwd: input.cwd,
-        activeModel: input.activeModel,
+        activeModel: runtimeManifest.effectiveModel,
         runtime: input.runtime,
         summary: {
             topLevelNodes: nodes.length,

package/dist/agent-runtime/profile-validation.js

@@ -58,6 +58,9 @@ export function validateAgentRuntimeProfileCapabilities(profile, capabilities) {
     if (enabledContextFiles.length > 0) {
         pushUnsupportedDeliveryDiagnostic(diagnostics, capabilities.context, "runtime_context_unsupported", "contextFiles", `Profile "${profile.profileName}" selects managed or automatic context`);
     }
+    if (enabledSubagents.length > 0) {
+        pushUnsupportedDeliveryDiagnostic(diagnostics, capabilities.context, "runtime_delegated_agent_context_unsupported", "subagents", `Profile "${profile.profileName}" requires delegated-agent management context`);
+    }
     if (profile.nativeSubagents !== undefined && typeof profile.nativeSubagents !== "boolean") {
         diagnostics.push({
             severity: "error",

package/dist/agent-runtime/resource-service.js

@@ -9,6 +9,7 @@ import { isHttpServer, loadConfigUnresolved, } from "../mcp/config.js";
 import { redactMcpRuntimeError as redactResourceError, scopePiboMcpServerConfig, verifyPiboMcpServer, } from "../mcp/runtime-session.js";
 import { getMcpAgentContextFileFromConfig } from "../mcp/agent-context.js";
 import { getInstalledCliToolContextFile } from "../tools/registry.js";
+import { getDelegatedAgentContextFile } from "../subagents/context.js";
 import { copyAgentRuntimeSkillDirectory, createAgentRuntimeResourcePaths, } from "./resource-files.js";
 const DEFAULT_MCP_VERIFY_TIMEOUT_MS = 15_000;
 const DEFAULT_MAX_SKILL_FILES = 2_048;
@@ -550,6 +551,21 @@ class RuntimeResourceSession {
                 this.diagnostics.push({ severity: "error", code: "runtime_context_file_failed", message, contributionId: id });
             }
         }
+        const delegatedAgents = getDelegatedAgentContextFile(this.input.profile.subagents);
+        if (delegatedAgents) {
+            this.requiredContributionIds.add("context:delegated-agents");
+            this.context.push({
+                id: "context:delegated-agents",
+                kind: "generated",
+                source: "generated",
+                intent: "developer",
+                label: "Delegated Agent Management",
+                required: true,
+                order: 250,
+                path: delegatedAgents.path,
+                content: delegatedAgents.content,
+            });
+        }
         const installedTools = getInstalledCliToolContextFile();
         if (installedTools) {
             this.context.push({

package/dist/agent-runtime/routed-session.js

@@ -9,6 +9,20 @@ const RUN_REMINDER_CAPABILITY_TOOLS = new Set([
     "pibo_run_cancel",
     "pibo_run_ack",
 ]);
+// Run reminders are autonomous service wakeups, so their provider/tool loop needs a deterministic boundary.
+const RUN_REMINDER_MAX_TOOL_EXECUTIONS = 64;
+const RUN_REMINDER_MAX_PROVIDER_ROUNDS = 64;
+const RUN_REMINDER_MAX_TOTAL_TOKENS = 2_000_000;
+const RUN_REMINDER_MAX_DURATION_MS = 15 * 60 * 1000;
+const RUN_REMINDER_MAX_REPEATED_TOOL_CALLS = 12;
+function serializedToolArgs(value) {
+    try {
+        return JSON.stringify(value) ?? String(value);
+    }
+    catch {
+        return String(value);
+    }
+}
 function errorMessage(error) {
     return error instanceof Error ? error.message : String(error);
 }
@@ -82,9 +96,11 @@ export class RuntimeRoutedSession {
     runtimeDisposePromise;
     forceDisposalStarted = false;
     drainPromise;
+    inFlightMessage;
     activeMessage;
     activeExecutionEvent;
     activeMessageFailed = false;
+    runReminderTurnGuard;
     activeAssistantIndex;
     nextAssistantIndex = 0;
     activeThinkingIndex;
@@ -409,6 +425,28 @@ export class RuntimeRoutedSession {
             this.notifyState();
             return true;
         }
+        const inFlight = this.inFlightMessage;
+        if (inFlight?.event.id === eventId) {
+            if (!inFlight.cancellation) {
+                inFlight.cancelled = true;
+                this.notifyMessagesInterrupted([inFlight.event], "message cancelled");
+                const active = this.activeMessage?.id === eventId;
+                inFlight.cancellation = (async () => {
+                    try {
+                        if (active)
+                            await this.runtimeSession.abort();
+                        await inFlight.settled;
+                    }
+                    catch (error) {
+                        inFlight.cancelled = false;
+                        inFlight.cancellation = undefined;
+                        throw error;
+                    }
+                })();
+            }
+            await inFlight.cancellation;
+            return true;
+        }
         if (this.activeMessage?.id === eventId) {
             this.notifyMessagesInterrupted([this.activeMessage], "message cancelled");
             await this.runtimeSession.abort();
@@ -462,6 +500,7 @@ export class RuntimeRoutedSession {
                 return;
             case "tool_execution_started":
                 this.emit(this.withActiveMessage({ ...event, type: "tool_execution_started", piboSessionId: this.piboSessionId }));
+                this.trackRunReminderTurnGuard("tool_execution_started", { toolName: event.toolName, args: event.args });
                 return;
             case "tool_execution_updated":
                 this.emit(this.withActiveMessage({ ...event, type: "tool_execution_updated", piboSessionId: this.piboSessionId }));
@@ -479,7 +518,10 @@ export class RuntimeRoutedSession {
                     cacheWriteTokens: event.usage.cacheWriteTokens,
                     reasoningTokens: event.usage.reasoningTokens,
                     totalTokens: event.usage.totalTokens,
+                    costUsd: event.usage.costUsd,
+                    provenance: this.activeMessage?.provenance,
                 }));
+                this.trackRunReminderTurnGuard("usage", { totalTokens: event.usage.totalTokens });
                 return;
             case "compaction_start":
                 this.emit(this.withActiveMessage({
@@ -593,9 +635,10 @@ export class RuntimeRoutedSession {
         }
     }
     async processQueuedMessage(event) {
+        const inFlight = this.beginInFlightMessage(event);
         try {
             const preflight = await this.options.messagePreflight?.(event);
-            if (this.disposed)
+            if (this.disposed || inFlight.cancelled)
                 return;
             if (preflight && !preflight.allowed) {
                 this.emit({
@@ -614,6 +657,10 @@ export class RuntimeRoutedSession {
                 });
                 return;
             }
+            this.activeMessage = event;
+            this.activeMessageFailed = false;
+            this.beginRunReminderTurnGuard(event);
+            this.resetContentIndices();
             this.emit({
                 type: "message_started",
                 piboSessionId: this.piboSessionId,
@@ -622,15 +669,14 @@ export class RuntimeRoutedSession {
                 source: event.source,
                 provenance: event.provenance,
             });
-            this.activeMessage = event;
-            this.activeMessageFailed = false;
-            this.resetContentIndices();
+            if (inFlight.cancelled)
+                return;
             await this.runtimeSession.prompt({
                 text: event.text,
                 source: promptSource(event.source),
                 capabilityScope: event.capabilityScope,
             });
-            if (this.disposed)
+            if (this.disposed || inFlight.cancelled)
                 return;
             if (!this.activeMessageFailed) {
                 this.emit({
@@ -643,7 +689,7 @@ export class RuntimeRoutedSession {
             }
         }
         catch (error) {
-            if (this.disposed)
+            if (this.disposed || inFlight.cancelled)
                 return;
             if (!this.activeMessageFailed) {
                 const message = errorMessage(error);
@@ -661,8 +707,103 @@ export class RuntimeRoutedSession {
             this.activeMessage = undefined;
             this.activeMessageFailed = false;
             this.resetContentIndices();
+            this.clearRunReminderTurnGuard();
+            if (this.inFlightMessage === inFlight)
+                this.inFlightMessage = undefined;
+            inFlight.resolveSettled();
+        }
+    }
+    beginInFlightMessage(event) {
+        let resolveSettled;
+        const inFlight = {
+            event,
+            cancelled: false,
+            settled: new Promise((resolve) => { resolveSettled = resolve; }),
+            resolveSettled: () => { resolveSettled?.(); },
+        };
+        this.inFlightMessage = inFlight;
+        return inFlight;
+    }
+    beginRunReminderTurnGuard(event) {
+        this.clearRunReminderTurnGuard();
+        if (event.source !== "service" || !event.text.startsWith("<pibo_run_notification>"))
+            return;
+        const guard = {
+            eventId: event.id,
+            toolExecutions: 0,
+            providerRounds: 0,
+            totalTokens: 0,
+            toolSignatures: new Map(),
+            tripped: false,
+        };
+        guard.timer = setTimeout(() => {
+            this.tripRunReminderTurnGuard(guard, `exceeded ${RUN_REMINDER_MAX_DURATION_MS / 60_000} minutes`);
+        }, RUN_REMINDER_MAX_DURATION_MS);
+        guard.timer.unref?.();
+        this.runReminderTurnGuard = guard;
+    }
+    clearRunReminderTurnGuard() {
+        const guard = this.runReminderTurnGuard;
+        if (!guard)
+            return;
+        if (guard.timer)
+            clearTimeout(guard.timer);
+        this.runReminderTurnGuard = undefined;
+    }
+    trackRunReminderTurnGuard(type, payload) {
+        const guard = this.runReminderTurnGuard;
+        if (!guard || guard.tripped || guard.eventId !== this.activeMessage?.id)
+            return;
+        if (type === "usage") {
+            const totalTokens = payload.totalTokens ?? 0;
+            guard.totalTokens += totalTokens;
+            guard.providerRounds += 1;
+            if (guard.totalTokens > RUN_REMINDER_MAX_TOTAL_TOKENS) {
+                this.tripRunReminderTurnGuard(guard, `exceeded ${RUN_REMINDER_MAX_TOTAL_TOKENS} total tokens`);
+                return;
+            }
+            if (guard.providerRounds > RUN_REMINDER_MAX_PROVIDER_ROUNDS) {
+                this.tripRunReminderTurnGuard(guard, `exceeded ${RUN_REMINDER_MAX_PROVIDER_ROUNDS} provider rounds`);
+            }
+            return;
+        }
+        const toolName = payload.toolName;
+        const args = payload.args;
+        guard.toolExecutions += 1;
+        if (guard.toolExecutions > RUN_REMINDER_MAX_TOOL_EXECUTIONS) {
+            this.tripRunReminderTurnGuard(guard, `exceeded ${RUN_REMINDER_MAX_TOOL_EXECUTIONS} tool executions`);
+            return;
+        }
+        const signature = `${String(toolName ?? "unknown")}:${serializedToolArgs(args)}`;
+        const repeated = (guard.toolSignatures.get(signature) ?? 0) + 1;
+        guard.toolSignatures.set(signature, repeated);
+        if (repeated > RUN_REMINDER_MAX_REPEATED_TOOL_CALLS) {
+            this.tripRunReminderTurnGuard(guard, `repeated the same tool call more than ${RUN_REMINDER_MAX_REPEATED_TOOL_CALLS} times`);
         }
     }
+    tripRunReminderTurnGuard(guard, reason) {
+        if (guard.tripped || this.runReminderTurnGuard !== guard)
+            return;
+        guard.tripped = true;
+        this.activeMessageFailed = true;
+        const error = `Run-reminder turn stopped because it ${reason}.`;
+        this.emit({
+            type: "session_error",
+            piboSessionId: this.piboSessionId,
+            eventId: guard.eventId,
+            error,
+            errorDetails: {
+                category: "runtime_abort",
+                errorClass: "runtime_abort",
+                code: "run_reminder_limit_exceeded",
+                origin: "runtime",
+                retryable: false,
+                userMessage: error,
+            },
+            provenance: this.activeMessage?.provenance,
+        });
+        void Promise.resolve(this.runtimeSession.abort()).catch(() => undefined);
+    }
     async processQueuedCompact(event) {
         this.activeExecutionEvent = event;
         try {
@@ -851,7 +992,10 @@ export class RuntimeRoutedSession {
     }
     activeAndQueuedMessages() {
         const messages = this.queue.flatMap((item) => item.kind === "message" ? [item.event] : []);
-        return this.activeMessage ? [this.activeMessage, ...messages] : messages;
+        const inFlight = this.inFlightMessage?.event;
+        if (this.activeMessage)
+            return [this.activeMessage, ...messages];
+        return inFlight ? [inFlight, ...messages] : messages;
     }
     notifyMessagesInterrupted(messages, reason) {
         if (messages.length === 0)
@@ -872,53 +1016,59 @@ export class RuntimeRoutedSession {
         this.nextThinkingIndex = 0;
     }
     withActiveMessage(event) {
-        if (this.activeMessage?.id && event.type === "assistant_delta") {
+        const activeMessage = this.activeMessage;
+        if (!activeMessage?.id)
+            return event;
+        const correlation = {
+            eventId: activeMessage.id,
+            ...(activeMessage.provenance ? { provenance: activeMessage.provenance } : {}),
+        };
+        if (event.type === "assistant_delta") {
             const assistantIndex = this.activeAssistantIndex ?? this.nextAssistantIndex;
             if (this.activeAssistantIndex === undefined) {
                 this.nextAssistantIndex += 1;
                 this.activeAssistantIndex = assistantIndex;
             }
-            return { ...event, eventId: this.activeMessage.id, assistantIndex };
+            return { ...event, ...correlation, assistantIndex };
         }
-        if (this.activeMessage?.id && event.type === "assistant_message") {
+        if (event.type === "assistant_message") {
             const assistantIndex = this.activeAssistantIndex ?? this.nextAssistantIndex;
             if (this.activeAssistantIndex === undefined)
                 this.nextAssistantIndex += 1;
             this.activeAssistantIndex = undefined;
-            return { ...event, eventId: this.activeMessage.id, assistantIndex };
+            return { ...event, ...correlation, assistantIndex };
         }
-        if (this.activeMessage?.id && event.type === "thinking_started") {
+        if (event.type === "thinking_started") {
             const thinkingIndex = this.nextThinkingIndex;
             this.nextThinkingIndex += 1;
             this.activeThinkingIndex = thinkingIndex;
-            return { ...event, eventId: this.activeMessage.id, thinkingIndex };
+            return { ...event, ...correlation, thinkingIndex };
         }
-        if (this.activeMessage?.id && (event.type === "thinking_delta" || event.type === "thinking_finished")) {
+        if (event.type === "thinking_delta" || event.type === "thinking_finished") {
             const thinkingIndex = this.activeThinkingIndex ?? this.nextThinkingIndex;
             if (this.activeThinkingIndex === undefined) {
                 this.nextThinkingIndex += 1;
                 this.activeThinkingIndex = thinkingIndex;
             }
-            const output = { ...event, eventId: this.activeMessage.id, thinkingIndex };
+            const output = { ...event, ...correlation, thinkingIndex };
             if (event.type === "thinking_finished")
                 this.activeThinkingIndex = undefined;
             return output;
         }
-        if (this.activeMessage?.id
-            && (event.type === "assistant_usage"
-                || event.type === "compaction_start"
-                || event.type === "compaction_end"
-                || event.type === "tool_call"
-                || event.type === "tool_execution_started"
-                || event.type === "tool_execution_updated"
-                || event.type === "tool_execution_finished"
-                || event.type === "approval_requested"
-                || event.type === "approval_resolved"
-                || event.type === "user_input_requested"
-                || event.type === "user_input_resolved"
-                || event.type === "session_error"
-                || event.type === "execution_result")) {
-            return { ...event, eventId: this.activeMessage.id };
+        if (event.type === "assistant_usage"
+            || event.type === "compaction_start"
+            || event.type === "compaction_end"
+            || event.type === "tool_call"
+            || event.type === "tool_execution_started"
+            || event.type === "tool_execution_updated"
+            || event.type === "tool_execution_finished"
+            || event.type === "approval_requested"
+            || event.type === "approval_resolved"
+            || event.type === "user_input_requested"
+            || event.type === "user_input_resolved"
+            || event.type === "session_error"
+            || event.type === "execution_result") {
+            return { ...event, ...correlation };
         }
         return event;
     }

package/dist/agent-runtime/testing/fake-adapter.js

@@ -12,6 +12,7 @@ export class FakeAgentRuntimeSession {
     disposed = false;
     aborted = false;
     promptIndex = 0;
+    activeScript;
     abortWaiters = [];
     prompts = [];
     disposeCalls = 0;
@@ -47,6 +48,7 @@ export class FakeAgentRuntimeSession {
         this.aborted = false;
         const turnId = `fake-turn-${this.promptIndex}`;
         const script = typeof this.script === "function" ? this.script(input, this.promptIndex) : this.script ?? {};
+        this.activeScript = script;
         this.emit({ type: "turn_started", turnId });
         try {
             if (script.waitForAbort) {
@@ -72,6 +74,7 @@ export class FakeAgentRuntimeSession {
             this.emit({ type: "turn_completed", turnId, status: "completed" });
         }
         finally {
+            this.activeScript = undefined;
             this.streaming = false;
         }
     }
@@ -84,6 +87,10 @@ export class FakeAgentRuntimeSession {
     }
     async abort() {
         this.abortCalls += 1;
+        if (this.activeScript?.abortFailWith)
+            throw new Error(this.activeScript.abortFailWith);
+        if (this.activeScript?.abortNeverSettles)
+            return;
         const wasStreaming = this.streaming;
         this.aborted = true;
         const waiters = this.abortWaiters;

package/dist/agent-runtimes/pi/adapter.js

@@ -210,7 +210,9 @@ export function semanticEventFromPibo(event) {
                     outputTokens: event.outputTokens,
                     cacheReadTokens: event.cacheReadTokens,
                     cacheWriteTokens: event.cacheWriteTokens,
+                    reasoningTokens: event.reasoningTokens,
                     totalTokens: event.totalTokens,
+                    costUsd: event.costUsd,
                 },
             };
         case "compaction_start":