@code-yeongyu/senpi 2026.10.26-1 → 2026.10.27-1

package/dist/modes/rpc/session-record-stream.d.ts

@@ -7,7 +7,7 @@
  * reads the same records from either.
  */
 import type { AgentAbortSource } from "../../core/agent-abort-provenance.ts";
-import type { AgentSession } from "../../core/agent-session.ts";
-/** Subscribes `output` to the session's records; returns the unsubscribe. */
-export declare function subscribeSessionRecords(session: AgentSession, output: (record: object) => void, onAbortSource?: (source: AgentAbortSource) => void): () => void;
+import type { AgentSession, AgentSessionEventListener } from "../../core/agent-session.ts";
+/** Subscribes `output` to the session's records (from `source`, by default `session.subscribe`); returns the unsubscribe. */
+export declare function subscribeSessionRecords(session: AgentSession, output: (record: object) => void, onAbortSource?: (source: AgentAbortSource) => void, source?: (listener: AgentSessionEventListener) => () => void): () => void;
 //# sourceMappingURL=session-record-stream.d.ts.map

package/dist/modes/rpc/session-record-stream.js

@@ -1,10 +1,10 @@
 import { clientFacingIdentity } from "./client-admission-record.js";
 import { ClientAdmissions } from "./client-admissions.js";
 import { ClientMessageEvents } from "./client-message-events.js";
-/** Subscribes `output` to the session's records; returns the unsubscribe. */
-export function subscribeSessionRecords(session, output, onAbortSource = () => { }) {
+/** Subscribes `output` to the session's records (from `source`, by default `session.subscribe`); returns the unsubscribe. */
+export function subscribeSessionRecords(session, output, onAbortSource = () => { }, source = (listener) => session.subscribe(listener)) {
     const correlatedEvents = new ClientMessageEvents(output, () => ClientAdmissions.forSession(session).hasIdentities);
-    return session.subscribe((event) => {
+    return source((event) => {
         if (event.type === "session_lifecycle") {
             // The connection adds the routing handle; classic stdio has no envelope.
             const { sessionId: _sessionId, ...record } = event;

package/dist/modes/rpc/session-structured-lanes.d.ts

@@ -0,0 +1,12 @@
+type StructuredReceiver = (record: object) => void;
+/**
+ * Per-session receivers of the internal structured lane (senpi#4272): the host-side owner of seeded records and
+ * block controls (S03/S04) registers here. Legacy sockets, stdout and the replay snapshot never read it.
+ */
+export declare class SessionStructuredLanes {
+    private readonly receivers;
+    observe(sessionId: string, receiver: StructuredReceiver): () => void;
+    accept(sessionId: string, record: object): void;
+}
+export {};
+//# sourceMappingURL=session-structured-lanes.d.ts.map

package/dist/modes/rpc/session-structured-lanes.js

@@ -0,0 +1,24 @@
+/**
+ * Per-session receivers of the internal structured lane (senpi#4272): the host-side owner of seeded records and
+ * block controls (S03/S04) registers here. Legacy sockets, stdout and the replay snapshot never read it.
+ */
+export class SessionStructuredLanes {
+    constructor() {
+        this.receivers = new Map();
+    }
+    observe(sessionId, receiver) {
+        const receivers = this.receivers.get(sessionId) ?? new Set();
+        receivers.add(receiver);
+        this.receivers.set(sessionId, receivers);
+        return () => {
+            receivers.delete(receiver);
+            if (receivers.size === 0 && this.receivers.get(sessionId) === receivers)
+                this.receivers.delete(sessionId);
+        };
+    }
+    accept(sessionId, record) {
+        for (const receiver of [...(this.receivers.get(sessionId) ?? [])])
+            receiver(record);
+    }
+}
+//# sourceMappingURL=session-structured-lanes.js.map

package/dist/modes/rpc/session-worker-client.js

@@ -5,6 +5,7 @@ import { ownProcessStartedAtMs } from "../../core/extensions/builtin/terminal/pr
 import { isSecurityNoticeState } from "../../core/security-notices.js";
 import { createWebViewBroker } from "../../core/webview/webview-broker.js";
 import { roleConnection } from "./connection-roles.js";
+import { answeredUiRequestId } from "./extension-ui-response.js";
 import { subscriptionLimits } from "../../core/subscription-limits/limit-store.js";
 import { SessionWorkerRequests } from "./session-worker-requests.js";
 import { acknowledge, acknowledgeGrant } from "./session-worker-signals.js";
@@ -125,11 +126,11 @@ export class SessionWorkerClient {
                 if (writer.handleMcpForm(command))
                     return;
                 const connection = writer.currentConnection();
-                if ("type" in command &&
-                    command.type === "extension_ui_response" &&
-                    "id" in command &&
-                    typeof command.id === "string" &&
-                    writer.acceptWorkerGrantResponse(sessionId, command.id, connection) === false)
+                const grantAnswer = "type" in command && command.type === "extension_ui_response"
+                    ? answeredUiRequestId(command)
+                    : undefined;
+                if (grantAnswer !== undefined &&
+                    writer.acceptWorkerGrantResponse(sessionId, grantAnswer, connection) === false)
                     return;
                 await this.request({
                     type: "command",

package/dist/modes/rpc/structured-session-records.d.ts

@@ -0,0 +1,12 @@
+import type { AgentSession } from "../../core/agent-session.ts";
+/**
+ * The engine-socket compact-updates rollout flag (`<brand>_ENGINE_SOCKET_COMPACT_UPDATES`), explicit-true only.
+ * Off, no session holds a structured subscription and every destination keeps its existing bytes.
+ */
+export declare function structuredLaneEnabled(): boolean;
+/**
+ * The session's internal structured lane, correlated like its legacy records: seeded `toJsonEvent` projections of
+ * every session event plus the three block controls, in session order. Never a legacy destination.
+ */
+export declare function subscribeStructuredSessionRecords(session: AgentSession, output: (record: object) => void): () => void;
+//# sourceMappingURL=structured-session-records.d.ts.map

package/dist/modes/rpc/structured-session-records.js

@@ -0,0 +1,88 @@
+import { getAssistantCapture } from "@earendil-works/pi-ai";
+import { envValue } from "../../core/brand.js";
+import { toJsonEvent } from "../json-event.js";
+import { subscribeSessionRecords } from "./session-record-stream.js";
+/**
+ * The engine-socket compact-updates rollout flag (`<brand>_ENGINE_SOCKET_COMPACT_UPDATES`), explicit-true only.
+ * Off, no session holds a structured subscription and every destination keeps its existing bytes.
+ */
+export function structuredLaneEnabled() {
+    const value = envValue("ENGINE_SOCKET_COMPACT_UPDATES");
+    return value === "1" || value === "true";
+}
+const SEEDS = { blockSeeds: 1 };
+/**
+ * Admits a block's records only after its own seed or insert reached this subscriber, so a subscriber that attached
+ * mid-message gets no seed, delta or control for that message, never a wrong one. A started block whose next record
+ * has no capture, or that has no accepted end when the message ends, is invalid: its later records are dropped and
+ * the assistant `message_end` names it in `invalidatedBlocks`, so a reader rebuilds it from the terminal message.
+ * A terminal that rewrote blocks from `rewrittenFrom` on invalidates every block at or above that index, and a
+ * `message_end` with no interpretable terminal capture (cancel, idle timeout) invalidates every block of the message.
+ * Blocks are addressed by the capture's own index (`capture.contentIndex ?? event.contentIndex`), never a drifted public one.
+ */
+class SeededBlockGate {
+    accept(record) {
+        if (record.type === "message_block_state" || record.type === "message_block_metadata")
+            return this.control(record, record.type === "message_block_state" ? record.phase : undefined);
+        if (record.type === "message_tool_arguments_reset")
+            return this.control(record);
+        if (record.type === "message_start" && record.message.role === "assistant") {
+            const seeded = toJsonEvent(record, SEEDS);
+            this.blocks = seeded && new Map();
+            return seeded;
+        }
+        if (record.type === "message_end" && record.message.role === "assistant")
+            return this.end(record);
+        if (record.type !== "message_update")
+            return toJsonEvent(record, SEEDS);
+        if (!this.blocks)
+            return undefined;
+        const seeded = toJsonEvent(record, SEEDS);
+        const update = record.assistantMessageEvent;
+        if (!("contentIndex" in update))
+            return seeded;
+        const index = getAssistantCapture(record)?.contentIndex ?? update.contentIndex;
+        const starts = update.type === "text_start" || update.type === "thinking_start" || update.type === "toolcall_start";
+        if (!starts && this.blocks.get(index) !== "open")
+            return undefined;
+        const ends = update.type === "text_end" || update.type === "thinking_end" || update.type === "toolcall_end";
+        this.blocks.set(index, seeded ? (ends ? "ended" : "open") : "invalid");
+        return seeded;
+    }
+    control(record, phase) {
+        const state = this.blocks?.get(record.contentIndex);
+        if (!this.blocks || state === "invalid")
+            return undefined;
+        if (phase === "insert")
+            this.blocks.set(record.contentIndex, "open");
+        else if (state === undefined || (phase === "end" && state !== "open"))
+            return undefined;
+        else if (phase === "end")
+            this.blocks.set(record.contentIndex, "ended");
+        return record;
+    }
+    end(record) {
+        const capture = getAssistantCapture(record);
+        const rewrittenFrom = capture?.message === undefined ? 0 : (capture.rewrittenFrom ?? Number.POSITIVE_INFINITY);
+        const invalidatedBlocks = [...(this.blocks ?? [])].flatMap(([index, state]) => state === "ended" && index < rewrittenFrom ? [] : [index]);
+        this.blocks = undefined;
+        const seeded = toJsonEvent(record, SEEDS) ?? record;
+        return invalidatedBlocks.length === 0
+            ? seeded
+            : { ...seeded, invalidatedBlocks: invalidatedBlocks.sort((a, b) => a - b) };
+    }
+}
+/**
+ * The session's internal structured lane, correlated like its legacy records: seeded `toJsonEvent` projections of
+ * every session event plus the three block controls, in session order. Never a legacy destination.
+ */
+export function subscribeStructuredSessionRecords(session, output) {
+    const gate = new SeededBlockGate();
+    return subscribeSessionRecords(session, output, undefined, (listener) => session.subscribeStructured((record) => {
+        const accepted = gate.accept(record);
+        // Correlation reads only `type`, `role` and outer fields, which seeded records and controls keep.
+        if (accepted)
+            listener(accepted);
+    }));
+}
+//# sourceMappingURL=structured-session-records.js.map

package/docs/extensions.md

@@ -2170,7 +2170,13 @@ session-notice identity. Restart redelivers unconsumed queued messages once, but
 never replays a consumed result or reruns an interrupted tool.
 
 `pi.lifecycle.reportChild({ taskId, childSessionId, runEpoch, generation, state,
-waitingOn?, terminal? })` persists runner-owned child state. Stale epoch/generation
+label?, since?, waitingOn?, terminal? })` persists runner-owned child state. `label`
+is a producer-authored name and `since` is the child's own state-entry time (ISO);
+an unparseable `since` is dropped. `waitingOn` takes the `SessionLifecycle.waitingOn`
+shape described in [RPC session lifecycle](rpc.md#session-lifecycle), named lists
+included; its counts stay authoritative and the child's human waits are not kept.
+A nonterminal report appears in the parent's `waitingOn.childReports` as
+`{ taskId, childSessionId, runEpoch, state, label?, since? }`. Stale epoch/generation
 pairs are ignored; a higher `runEpoch` clears the old terminal status. Terminal
 values are `completed`, `error`, `lost`, `interrupted`, and `cancelled`. Child UI
 requests remain automatically answered by their runners, not routed to a person.

package/docs/rpc.md

@@ -145,8 +145,23 @@ The shared `SessionLifecycle` type is exported by `@code-yeongyu/senpi`:
 - `seq`, `epoch`, `epochOrigin` (`human` or `automatic`), `humanInputRevision`,
   `selfSettleEligible`, `restoring`, `persisted`, `runPaused`, and `since` (ISO time).
 - `role` (`root` or `child`), `rootSessionId`, and optional `parentSessionId` and `taskId`.
-- Optional `waitingOn`: `{ children, background, human }`. Background entries carry
-  `source`, `activeCount`, and optional `retryAtMs`. Human entries carry `kind`,
+- Optional `waitingOn`: `{ children, background, human, childSources?, childReports?, childReportsOmitted? }`.
+  `children` and each source's `activeCount` are the authoritative counts; every named list below is
+  supplemental and may be incomplete, so never derive a count from a list's length. `children` is the
+  larger of the nonterminal child reports and the summed `childSources` counts.
+  Background entries carry `source`, `activeCount`, optional `items`, optional `omittedItems`, and
+  optional `retryAtMs`. `childSources` entries carry `source`, `activeCount`, optional `items`, and
+  optional `omittedItems`. Each item is `{ id, label?, startedAt? }` (`startedAt` is ISO time), taken
+  from the producer's `wake_source_state` snapshot: its `items`, or the legacy `monitors` list when
+  `items` is missing or null. Terminal monitors are named by their stable `mon_` id. Each list is a
+  snapshot: entries whose `id` is not a non-blank string are dropped, duplicates collapse to one entry
+  per `id`, the list is sorted by `id`, and at most 32 entries are kept. `omittedItems` is the
+  producer's own omitted count plus any valid items cut at 32; it is not `activeCount` minus the list
+  length. Invalid detail drops only the detail, never the count.
+  `childReports` lists nonterminal reports from `reportChild` as
+  `{ taskId, childSessionId, runEpoch, state, label?, since? }`, excluding reports about the session
+  itself, sorted by `taskId` and capped at 32; `childReportsOmitted` counts the reports cut by that cap.
+  Human entries carry `kind`,
   `originSessionId`, `requestId`, `revision`, `since`, and optional child identity/label.
   Human kinds are `question`, `approval`, `goal_blocked`, `goal_paused`, `stalled`,
   and `interrupted_run`; attention remains visible even when a hold wins precedence.

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@code-yeongyu/senpi",
-	"version": "2026.10.26-1",
+	"version": "2026.10.27-1",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"type": "module",
 	"piConfig": {
@@ -71,9 +71,9 @@
 	},
 	"dependencies": {
 		"@earendil-works/chord": "0.99.1",
-		"@earendil-works/pi-agent-core": "npm:@code-yeongyu/senpi-agent-core@2026.10.26-1",
-		"@earendil-works/pi-ai": "npm:@code-yeongyu/senpi-ai@2026.10.26-1",
-		"@earendil-works/pi-tui": "npm:@code-yeongyu/senpi-tui@2026.10.26-1",
+		"@earendil-works/pi-agent-core": "npm:@code-yeongyu/senpi-agent-core@2026.10.27-1",
+		"@earendil-works/pi-ai": "npm:@code-yeongyu/senpi-ai@2026.10.27-1",
+		"@earendil-works/pi-tui": "npm:@code-yeongyu/senpi-tui@2026.10.27-1",
 		"@silvia-odwyer/photon-node": "0.3.4",
 		"ajv": "8.20.0",
 		"chalk": "6.0.0",
@@ -93,8 +93,8 @@
 		"yaml": "2.9.1",
 		"@anthropic-ai/claude-agent-sdk": "0.3.306",
 		"@anthropic-ai/sdk": "0.127.0",
-		"@code-yeongyu/senpi-codemode": "2026.10.26-1",
-		"@earendil-works/pi-pty": "npm:@code-yeongyu/senpi-pty@2026.10.26-1",
+		"@code-yeongyu/senpi-codemode": "2026.10.27-1",
+		"@earendil-works/pi-pty": "npm:@code-yeongyu/senpi-pty@2026.10.27-1",
 		"@modelcontextprotocol/sdk": "1.32.1",
 		"@mozilla/readability": "0.6.0",
 		"linkedom": "0.18.13",

package/dist/bundle/chunks/chunk-GQJYNFMO.js

@@ -1,2 +0,0 @@
-import { createRequire as __piCreateRequire } from "node:module"; const require = __piCreateRequire(import.meta.url); { const __piWorkerThreads = require("node:worker_threads"); if (typeof __piWorkerThreads.markAsUncloneable !== "function") { __piWorkerThreads.markAsUncloneable = () => {}; } }
-var captures=new WeakMap,readers=new WeakMap,writers=new WeakMap,states=new WeakMap,demanded=new WeakSet,warned=new WeakSet,NO_CHANGE=Object.freeze({}),subscribers=0,capturedAny=!1;function subscribeAssistantCapture(){subscribers++;let held=!0;return()=>{held&&subscribers--,held=!1}}function setAssistantReader(owner,reader){readers.set(owner,reader)}function setAssistantProgressWriter(owner,writer){writers.set(owner,writer)}function enableAssistantCapture(owner){states.has(owner)||states.set(owner,void 0)}function activeState(owner){let state=states.get(owner);if(state!==void 0||!states.has(owner))return state??void 0;let decided=subscribers>0||demanded.has(owner)?{positions:new Map,metadata:new Map,insertCopies:new Map,failedBlocks:new Set}:null;return capturedAny||=decided!==null,states.set(owner,decided),decided??void 0}function dropCapture(owner,error,state,contentIndex){contentIndex!==void 0&&state?.failedBlocks.add(contentIndex),!warned.has(owner)&&(warned.add(owner),console.warn("[assistant-capture] could not build an internal capture record; that block's records are dropped",error))}function pushAssistantProgress(owner,progress){let writer=writers.get(owner);if(!writer)return;if(Object.isFrozen(progress)){writer(progress);return}let state=activeState(owner);if(!(!state||state.failedBlocks.has(progress.contentIndex)))try{writer(freezeProgress(state,progress))}catch(error){dropCapture(owner,error,state,progress.contentIndex)}}function freezeProgress(state,progress){if(progress.type==="message_tool_arguments_reset"&&state.positions.set(progress.contentIndex,{offset:progress.rawArgumentPrefix.length,parsedThrough:progress.parsedThrough}),progress.type!=="message_block_state")return Object.freeze({...progress});let previous=state.insertCopies.get(progress.contentIndex),current=publicBlock(progress.block),block=previous!==void 0&&sameValue(current,previous)?previous:freezeCapture(current);return progress.phase==="insert"?state.insertCopies.set(progress.contentIndex,block):state.insertCopies.delete(progress.contentIndex),Object.freeze({...progress,block})}function pushAssistantSignature(owner,contentIndex,block,signature){!signature||signature===(block.type==="text"?block.textSignature:block.thinkingSignature)||pushAssistantProgress(owner,{type:"message_block_metadata",contentIndex,...block.type==="text"?{textSignature:signature}:{thinkingSignature:signature}})}function pushAssistantCompleteBlock(owner,contentIndex,block){for(let phase of["insert","end"])pushAssistantProgress(owner,{type:"message_block_state",contentIndex,phase,block})}function assistantRecords(source){demanded.add(source);let read=readers.get(source);return{[Symbol.asyncIterator]:()=>read?.(entry=>({value:"event"in entry?entry.event:entry.progress,done:!1}))??source[Symbol.asyncIterator]()}}function assistantEvents(source,onProgress){let read=readers.get(source);return{[Symbol.asyncIterator]:()=>read?.(entry=>{if("event"in entry)return{value:entry.event,done:!1};onProgress(entry.progress)})??source[Symbol.asyncIterator]()}}function getAssistantCapture(event){return captures.get(event)}function isAssistantProgress(event){return event.type==="message_block_state"||event.type==="message_block_metadata"||event.type==="message_tool_arguments_reset"}function freezeCapture(value){let freeze=part=>{if(!(part===null||typeof part!="object"||Object.isFrozen(part))){for(let child of Object.values(part))freeze(child);Object.freeze(part)}},copy=structuredClone(value);return freeze(copy),copy}function publicBlock(block){return Object.fromEntries({text:["type","text","audience","textSignature"],thinking:["type","thinking","thinkingSignature","redacted","startedAt","endedAt"],toolCall:["type","id","name","arguments","incomplete","errorMessage","thoughtSignature","namespace"],providerNative:["type","subtype","raw"]}[block.type].filter(key=>key in block).map(key=>[key,Reflect.get(block,key)]))}function sameValue(left,right){if(left===right)return!0;if(!isPlainData(left)||!isPlainData(right)||Array.isArray(left)!==Array.isArray(right))return!1;let keys=Object.keys(left);return keys.length===Object.keys(right).length&&keys.every(key=>Object.hasOwn(right,key)&&sameValue(Reflect.get(left,key),Reflect.get(right,key)))}function isPlainData(value){if(typeof value!="object"||value===null)return!1;let prototype=Object.getPrototypeOf(value);return prototype===Object.prototype||prototype===Array.prototype||prototype===null}function dropAssistantCapture(event){capturedAny&&captures.delete(event)}function carryAssistantCapture(source,target,terminal){let capture=captures.get(source);if(!capture)return target;try{captures.set(target,terminal?Object.freeze({...capture,message:freezeCapture({...terminal,content:terminal.content.map(publicBlock)})}):capture)}catch(error){dropCapture(source,error)}return target}function captureAssistantEvent(owner,event,hint={}){let state=activeState(owner);if(!state||captures.has(event))return;let contentIndex="contentIndex"in event?hint.contentIndex??event.contentIndex:void 0;if(!(contentIndex!==void 0&&state.failedBlocks.has(contentIndex)))try{captures.set(event,buildCapture(state,event,hint))}catch(error){dropCapture(owner,error,state,contentIndex)}}function buildCapture(state,event,hint){let message=event.type==="done"?event.message:event.type==="error"?event.error:event.partial,usage=usageCopy(state,message.usage);if(!("contentIndex"in event))return Object.freeze({usage,metadata:changedMetadata(state,message),message:freezeCapture({...message,content:message.content.map(publicBlock)})});let index=hint.contentIndex??event.contentIndex,own=index===event.contentIndex?{}:{contentIndex:index};if("delta"in event){let position=state.positions.get(index)??{offset:0,parsedThrough:0},offset=hint.offset??position.offset;return position.offset=offset+event.delta.length,event.type==="toolcall_delta"&&event.delta.length>0&&(position.parsedThrough=hint.parsedThrough??Math.max(position.parsedThrough,position.offset)),state.positions.set(index,position),Object.freeze({usage,offset,...own,...event.type==="toolcall_delta"?{parsedThrough:position.parsedThrough}:{}})}let metadata=changedMetadata(state,message),block=freezeCapture(publicBlock(event.type==="toolcall_end"?event.toolCall:message.content[index]));if(event.type!=="text_start"&&event.type!=="thinking_start"&&event.type!=="toolcall_start")return Object.freeze({usage,metadata,block,...own});let rawArgumentPrefix=hint.rawArgumentPrefix??"",coveredCodeUnits=block.type==="text"?block.text.length:block.type==="thinking"?block.thinking.length:rawArgumentPrefix.length,parsedThrough=hint.parsedThrough??0;return state.positions.set(index,{offset:hint.offset??coveredCodeUnits,parsedThrough}),Object.freeze({usage,metadata,block,coveredCodeUnits,...own,...block.type==="toolCall"?{rawArgumentPrefix,parsedThrough}:{}})}function usageCopy(state,usage){if(state.usage!==void 0&&sameValue(usage,state.usage))return state.usage;let copy=Object.freeze({...usage,cost:Object.freeze({...usage.cost}),...usage.contextUsage?{contextUsage:Object.freeze({...usage.contextUsage})}:{}});return state.usage=copy,copy}function changedMetadata(state,message){let changed={};for(let key of Object.keys(message)){if(key==="content"||key==="usage")continue;let value=Reflect.get(message,key);(!state.metadata.has(key)||state.metadata.get(key)!==value)&&(changed[key]=value)}for(let key of state.metadata.keys())key in message||(changed[key]=null);let frozen=Object.keys(changed).length===0?NO_CHANGE:freezeCapture(changed);for(let key of Object.keys(changed))key in message?state.metadata.set(key,Reflect.get(message,key)):state.metadata.delete(key);return frozen}var FifoQueue=class{constructor(){this.incoming=[],this.outgoing=[]}get length(){return this.incoming.length+this.outgoing.length}enqueue(value){this.incoming.push(value)}prepend(value){this.outgoing.push(value)}dequeue(){if(this.outgoing.length===0)for(;this.incoming.length>0;)this.outgoing.push(this.incoming.pop());return this.outgoing.pop()}},EventStream=class{#queue;#queueHead;#failed;#error;#localWorkDepth;constructor(isComplete,extractResult){this.#queue=[],this.#queueHead=0,this.waiting=new FifoQueue,this.done=!1,this.#failed=!1,this.#localWorkDepth=0,this.isComplete=isComplete,this.extractResult=extractResult,this.finalResultPromise=new Promise((resolve,reject)=>{this.resolveFinalResult=resolve,this.rejectFinalResult=reject}),this.finalResultPromise.catch(()=>{})}get queue(){return this.#queue.slice(this.#queueHead).flatMap(entry=>"event"in entry?[entry.event]:[])}#enqueue(event){this.#queue.push(event)}#dequeue(){let event=this.#queue[this.#queueHead];if(event===void 0)throw new Error("EventStream queue underflow");return this.#queueHead++,this.#queueHead>1024&&this.#queueHead*2>=this.#queue.length&&(this.#queue=this.#queue.slice(this.#queueHead),this.#queueHead=0),event}push(event){this.done||(this.isComplete(event)&&(this.done=!0,this.resolveFinalResult(this.extractResult(event))),this.#deliver({event}))}enqueueProgress(progress){this.done||this.#deliver({progress})}#deliver(entry){let waiter=this.waiting.dequeue();waiter?waiter.resolve({value:entry,done:!1}):this.#enqueue(entry)}end(result){for(this.done=!0,result!==void 0&&this.resolveFinalResult(result);this.waiting.length>0;){let waiter=this.waiting.dequeue();waiter&&waiter.resolve({value:void 0,done:!0})}}fail(error){if(!this.done)for(this.done=!0,this.#failed=!0,this.#error=error,this.rejectFinalResult(error);this.waiting.length>0;){let waiter=this.waiting.dequeue();waiter&&waiter.reject(error)}}[Symbol.asyncIterator](){return this.mapIterator(entry=>"event"in entry?{value:entry.event,done:!1}:void 0)}mapIterator(project){return{next:()=>{for(;this.#queueHead<this.#queue.length;){let result=project(this.#dequeue());if(result)return Promise.resolve(result)}return this.#failed?Promise.reject(this.#error):this.done?Promise.resolve({value:void 0,done:!0}):new Promise((resolve,reject)=>{let waiter={reject,resolve:next=>{let result=next.done?{value:void 0,done:!0}:project(next.value);result?resolve(result):this.waiting.prepend(waiter)}};this.waiting.enqueue(waiter)})}}}result(){return this.finalResultPromise}async trackLocalWork(work){this.#localWorkDepth++;try{return await work}finally{this.#localWorkDepth--}}hasPendingLocalWork(){return this.#localWorkDepth>0}},AssistantMessageEventStream=class _AssistantMessageEventStream extends EventStream{constructor(options={}){super(event=>event.type==="done"||event.type==="error",event=>{if(event.type==="done")return event.message;if(event.type==="error")return event.error;throw new Error("Unexpected event type for final result")}),options.captureBlocks&&enableAssistantCapture(this),setAssistantProgressWriter(this,progress=>this.enqueueProgress(progress)),new.target.prototype[Symbol.asyncIterator]===_AssistantMessageEventStream.prototype[Symbol.asyncIterator]&&setAssistantReader(this,project=>this.mapIterator(project))}push(event,hint){this.done||(captureAssistantEvent(this,event,hint),super.push(event))}[Symbol.asyncIterator](){return this.mapIterator(entry=>{if("event"in entry)return dropAssistantCapture(entry.event),{value:entry.event,done:!1}})}};function createAssistantMessageEventStream(){return new AssistantMessageEventStream}function formatThrownValue(value){return value instanceof Error?value.message||value.name:typeof value=="string"?value:String(value)}function extractDiagnosticError(error){if(!(error instanceof Error))return{name:"ThrownValue",message:formatThrownValue(error)};let code=error.code;return{name:error.name||void 0,message:error.message||error.name,stack:error.stack,code:typeof code=="string"||typeof code=="number"?code:void 0}}function createAssistantMessageDiagnostic(type,error,details){return{type,timestamp:Date.now(),error:extractDiagnosticError(error),details}}function appendAssistantMessageDiagnostic(message,diagnostic){message.diagnostics=[...message.diagnostics??[],diagnostic]}export{subscribeAssistantCapture,setAssistantReader,enableAssistantCapture,pushAssistantProgress,pushAssistantSignature,pushAssistantCompleteBlock,assistantRecords,assistantEvents,getAssistantCapture,isAssistantProgress,carryAssistantCapture,EventStream,AssistantMessageEventStream,createAssistantMessageEventStream,formatThrownValue,extractDiagnosticError,createAssistantMessageDiagnostic,appendAssistantMessageDiagnostic};