@pasko70/pibo 2.5.1 → 3.0.0

package/dist/agent-runtimes/pi/openai-response-observer.js

@@ -0,0 +1,102 @@
+export function withOpenAiResponseEventObserver(options, observer) {
+    const fetchImpl = options?.fetch ?? globalThis.fetch;
+    return {
+        ...(options ?? {}),
+        // Pi does not expose raw events from its shared Codex WebSocket transport.
+        // SSE keeps observation request-scoped instead of replacing global constructors.
+        transport: "sse",
+        fetch: async (input, init) => observeOpenAiSseResponse(await fetchImpl(input, init), observer),
+    };
+}
+export function observeOpenAiSseResponse(response, observer) {
+    if (!response.body || !response.headers.get("content-type")?.toLowerCase().includes("text/event-stream")) {
+        return response;
+    }
+    const reader = response.body.getReader();
+    const parser = new OpenAiSseParser(observer);
+    let cancelled = false;
+    const body = new ReadableStream({
+        async pull(controller) {
+            try {
+                const chunk = await reader.read();
+                if (cancelled)
+                    return;
+                if (chunk.done) {
+                    parser.finish();
+                    reader.releaseLock();
+                    controller.close();
+                    return;
+                }
+                parser.push(chunk.value);
+                controller.enqueue(chunk.value);
+            }
+            catch (error) {
+                if (cancelled)
+                    return;
+                reader.releaseLock();
+                controller.error(error);
+            }
+        },
+        async cancel(reason) {
+            cancelled = true;
+            try {
+                await reader.cancel(reason);
+            }
+            finally {
+                reader.releaseLock();
+            }
+        },
+    }, { highWaterMark: 0 });
+    return new Response(body, {
+        status: response.status,
+        statusText: response.statusText,
+        headers: response.headers,
+    });
+}
+class OpenAiSseParser {
+    observer;
+    decoder = new TextDecoder();
+    buffer = "";
+    constructor(observer) {
+        this.observer = observer;
+    }
+    push(chunk) {
+        this.buffer += this.decoder.decode(chunk, { stream: true });
+        this.drain();
+    }
+    finish() {
+        this.buffer += this.decoder.decode();
+        this.drain(true);
+    }
+    drain(final = false) {
+        this.buffer = this.buffer.replaceAll("\r\n", "\n");
+        let separator = this.buffer.indexOf("\n\n");
+        while (separator >= 0) {
+            this.observeBlock(this.buffer.slice(0, separator));
+            this.buffer = this.buffer.slice(separator + 2);
+            separator = this.buffer.indexOf("\n\n");
+        }
+        if (final && this.buffer.trim()) {
+            this.observeBlock(this.buffer);
+            this.buffer = "";
+        }
+    }
+    observeBlock(block) {
+        const data = block
+            .split("\n")
+            .filter((line) => line.startsWith("data:"))
+            .map((line) => line.slice(5).trim())
+            .join("\n")
+            .trim();
+        if (data && data !== "[DONE]")
+            observeJson(data, this.observer);
+    }
+}
+function observeJson(value, observer) {
+    try {
+        observer(JSON.parse(value));
+    }
+    catch {
+        // Provider observation must never interfere with the provider stream.
+    }
+}

package/dist/agent-runtimes/pi/routed-session.js

@@ -8,6 +8,7 @@ import { PIBO_PROVIDER_RECOVERY_MESSAGE_TYPE, PIBO_PROVIDER_RECOVERY_PROMPT, Pib
 import { PiAgentRuntimeAuthController } from "./auth.js";
 import { piIntentTracingInstalled, piToolIntentField, splitPiToolIntentArguments } from "./intent-tracing.js";
 import { loadModelCatalog as loadPiModelCatalog } from "./model-catalog.js";
+import { withOpenAiResponseEventObserver } from "./openai-response-observer.js";
 import { PIBO_TRANSCRIPT_INTEGRITY_RESUME_MESSAGE_TYPE, PIBO_TRANSCRIPT_INTEGRITY_RESUME_PROMPT, PiboTranscriptIntegrityError, claimPiboTranscriptIntegrityContinuation, settlePiboTranscriptIntegrityContinuation, } from "../../core/transcript-integrity.js";
 const FAST_SERVICE_TIER = "priority";
 const RUN_REMINDER_CAPABILITY_TOOLS = new Set([
@@ -24,6 +25,11 @@ function modelSupportsFastServiceTier(model) {
         return true;
     return model.api === "openai-responses" && (model.provider === "openai" || model.provider === "openai-codex");
 }
+function modelUsesOpenAiResponses(model) {
+    if (model?.api === "openai-codex-responses")
+        return true;
+    return model?.api === "openai-responses" && (model.provider === "openai" || model.provider === "openai-codex");
+}
 function withFastServiceTier(payload) {
     if (!payload || typeof payload !== "object" || Array.isArray(payload))
         return payload;
@@ -250,6 +256,9 @@ function normalizeToolExecutionEvent(piboSessionId, candidate, context) {
     }
     return undefined;
 }
+function providerWebSearchToolCallId(rawId) {
+    return rawId.startsWith("provider:web_search:") ? rawId : `provider:web_search:${rawId}`;
+}
 function normalizeProviderWebSearchEvent(piboSessionId, candidate) {
     const item = recordValue(candidate.item) ?? recordValue(candidate.assistantMessageEvent?.item);
     const itemType = stringValue(item?.type);
@@ -269,14 +278,22 @@ function normalizeProviderWebSearchEvent(piboSessionId, candidate) {
             ? `content-${candidate.assistantMessageEvent.contentIndex}`
             : undefined) ??
         "active";
-    const toolCallId = rawId.startsWith("provider:web_search:") ? rawId : `provider:web_search:${rawId}`;
-    const query = stringValue(candidate.query) ??
-        stringValue(candidate.assistantMessageEvent?.query) ??
-        stringValue(action?.query) ??
-        stringValue(item?.query) ??
-        stringValue(item?.search_query);
-    const sources = firstArray(candidate.sources, candidate.assistantMessageEvent?.sources, item?.sources, item?.results, item?.citations);
-    const args = { providerTool: "web_search", ...(query ? { query } : {}) };
+    const toolCallId = providerWebSearchToolCallId(rawId);
+    const query = firstTrimmedString(candidate.query, candidate.assistantMessageEvent?.query, action?.query, item?.query, item?.search_query);
+    const queries = firstStringArray(action?.queries, item?.queries);
+    const url = normalizeProviderWebUrl(firstTrimmedString(action?.url, item?.url));
+    const pattern = firstTrimmedString(action?.pattern, item?.pattern);
+    const actionType = normalizeProviderWebSearchActionType(action?.type, { query, queries, url, pattern });
+    const rawSources = firstArray(candidate.sources, candidate.assistantMessageEvent?.sources, action?.sources, item?.sources, item?.results, item?.citations);
+    const sources = normalizeProviderWebSearchSources(rawSources);
+    const details = {
+        ...(actionType ? { actionType } : {}),
+        ...(query ? { query } : {}),
+        ...(queries ? { queries } : {}),
+        ...(url ? { url } : {}),
+        ...(pattern ? { pattern } : {}),
+    };
+    const args = { providerTool: "web_search", ...details };
     if (status === "running") {
         return {
             type: "tool_execution_started",
@@ -295,12 +312,106 @@ function normalizeProviderWebSearchEvent(piboSessionId, candidate) {
         result: status === "error"
             ? (error ?? "Web search failed")
             : {
-                ...(query ? { query } : {}),
-                ...(sources ? { sources, sourceCount: sources.length } : {}),
+                ...details,
+                ...(rawSources ? { sources, sourceCount: sources.length } : {}),
             },
         isError: status === "error",
     };
 }
+function inferProviderWebSearchActionType(details) {
+    if (details.pattern)
+        return "find_in_page";
+    if (details.url)
+        return "open_page";
+    if (details.query || details.queries)
+        return "search";
+    return undefined;
+}
+function normalizeProviderWebSearchActionType(value, details) {
+    const explicit = firstTrimmedString(value)?.toLowerCase();
+    if (explicit === "search")
+        return "search";
+    if (explicit === "open" || explicit === "open_page")
+        return "open_page";
+    if (explicit === "find" || explicit === "find_in_page")
+        return "find_in_page";
+    if (explicit === "other")
+        return "other";
+    return inferProviderWebSearchActionType(details);
+}
+function normalizeProviderWebSearchSources(candidates) {
+    if (!candidates)
+        return [];
+    const sources = new Map();
+    for (const candidate of candidates) {
+        const record = recordValue(candidate);
+        const rawUrl = typeof candidate === "string"
+            ? candidate
+            : firstTrimmedString(record?.url, record?.href, record?.link);
+        const url = normalizeProviderWebUrl(rawUrl, true);
+        if (!url)
+            continue;
+        const title = firstTrimmedString(record?.title, record?.name);
+        const existing = sources.get(url);
+        if (!existing || (!existing.title && title))
+            sources.set(url, { url, ...(title ? { title } : {}) });
+    }
+    return [...sources.values()];
+}
+function normalizeProviderWebUrl(value, stripHash = false) {
+    if (!value)
+        return undefined;
+    try {
+        const url = new URL(value);
+        if ((url.protocol !== "https:" && url.protocol !== "http:") || url.username || url.password)
+            return undefined;
+        if (stripHash)
+            url.hash = "";
+        return url.href;
+    }
+    catch {
+        return undefined;
+    }
+}
+function providerWebSearchCompletionIsProvisional(candidate) {
+    const rawEventType = (stringValue(candidate.type) ?? stringValue(candidate.assistantMessageEvent?.type))?.toLowerCase();
+    if (!rawEventType?.includes("web_search_call.completed"))
+        return false;
+    return !recordValue(candidate.item) && !recordValue(candidate.assistantMessageEvent?.item);
+}
+function providerResponseCompleted(candidate) {
+    const rawEventType = (stringValue(candidate.type) ?? stringValue(candidate.assistantMessageEvent?.type))?.toLowerCase();
+    return rawEventType === "response.completed";
+}
+function normalizeNativeProviderWebSearchEvent(event) {
+    if (!event ||
+        (event.type !== "tool_execution_started" &&
+            event.type !== "tool_execution_updated" &&
+            event.type !== "tool_execution_finished") ||
+        event.toolName !== "web_search") {
+        return undefined;
+    }
+    return { ...event, toolCallId: providerWebSearchToolCallId(event.toolCallId) };
+}
+function providerWebSearchArgsFromResult(result) {
+    const details = recordValue(result);
+    return {
+        providerTool: "web_search",
+        ...(details?.actionType ? { actionType: details.actionType } : {}),
+        ...(details?.query ? { query: details.query } : {}),
+        ...(details?.queries ? { queries: details.queries } : {}),
+        ...(details?.url ? { url: details.url } : {}),
+        ...(details?.pattern ? { pattern: details.pattern } : {}),
+    };
+}
+function providerWebSearchArgsKey(args) {
+    try {
+        return JSON.stringify(args);
+    }
+    catch {
+        return String(args);
+    }
+}
 function providerWebSearchStatus(rawType, rawStatus) {
     const type = rawType.toLowerCase();
     const status = stringValue(rawStatus)?.toLowerCase();
@@ -322,6 +433,29 @@ function firstArray(...values) {
     }
     return undefined;
 }
+function firstStringArray(...values) {
+    for (const value of values) {
+        if (!Array.isArray(value))
+            continue;
+        const strings = [...new Set(value.flatMap((item) => {
+                const normalized = firstTrimmedString(item);
+                return normalized ? [normalized] : [];
+            }))];
+        if (strings.length > 0)
+            return strings;
+    }
+    return undefined;
+}
+function firstTrimmedString(...values) {
+    for (const value of values) {
+        if (typeof value !== "string")
+            continue;
+        const trimmed = value.trim();
+        if (trimmed)
+            return trimmed;
+    }
+    return undefined;
+}
 export function normalizePiEvent(piboSessionId, event, context) {
     if (!event || typeof event !== "object")
         return undefined;
@@ -462,13 +596,16 @@ export class RoutedSession {
     drainPromise;
     inFlightMessage;
     fastMode = false;
-    fastModePatchedAgents = new WeakSet();
+    providerRequestPatchedAgents = new WeakSet();
+    providerWebSearchObservationEnabled = false;
+    providerWebSearchLifecycle = new Map();
     activeMessage;
     activeExecutionEvent;
     activeAssistantIndex;
     nextAssistantIndex = 0;
     activeThinkingIndex;
     nextThinkingIndex = 0;
+    sessionIdentityOperationInFlight = false;
     pendingAssistantError;
     pendingAssistantErrorRetryable = false;
     activeMessageFailed = false;
@@ -493,27 +630,43 @@ export class RoutedSession {
         this.messagePreflight = messagePreflight;
         this.fastMode = initialFastMode && this.fastModeSupported();
         this.bindRuntimeSession();
-        this.patchFastModeProviderRequest();
+        this.patchProviderRequest();
         this.patchAgentContinue();
         this.runtime.setRebindSession(async () => {
             this.bindRuntimeSession();
-            this.patchFastModeProviderRequest();
+            this.patchProviderRequest();
             this.patchAgentContinue();
         });
     }
-    patchFastModeProviderRequest() {
+    enableProviderWebSearchObservation() {
+        this.providerWebSearchObservationEnabled = true;
+    }
+    patchProviderRequest() {
         const agent = this.runtime.session.agent;
         if (!agent || typeof agent !== "object")
             return;
-        if (this.fastModePatchedAgents.has(agent))
+        if (this.providerRequestPatchedAgents.has(agent))
             return;
-        this.fastModePatchedAgents.add(agent);
-        const originalStreamFn = typeof agent.streamFn === "function" ? agent.streamFn.bind(agent) : undefined;
-        if (originalStreamFn) {
-            agent.streamFn = (model, context, options) => {
-                const nextOptions = this.shouldUseFastServiceTier(model) ? withFastServiceTierOption(options) : options;
+        this.providerRequestPatchedAgents.add(agent);
+        const streamFunctionKey = typeof agent.streamFunction === "function"
+            ? "streamFunction"
+            : typeof agent.streamFn === "function"
+                ? "streamFn"
+                : undefined;
+        const originalStreamFn = streamFunctionKey ? agent[streamFunctionKey]?.bind(agent) : undefined;
+        if (streamFunctionKey && originalStreamFn) {
+            const wrappedStreamFn = (model, context, options) => {
+                let nextOptions = this.shouldUseFastServiceTier(model) ? withFastServiceTierOption(options) : options;
+                if (this.providerWebSearchObservationEnabled && modelUsesOpenAiResponses(model)) {
+                    const activeEventId = this.activeMessage?.id;
+                    nextOptions = withOpenAiResponseEventObserver(nextOptions, (event) => this.observeProviderResponseEvent(event, activeEventId));
+                }
                 return originalStreamFn(model, context, nextOptions);
             };
+            if (streamFunctionKey === "streamFunction")
+                agent.streamFunction = wrappedStreamFn;
+            else
+                agent.streamFn = wrappedStreamFn;
         }
         const originalOnPayload = agent.onPayload?.bind(agent);
         agent.onPayload = async (payload, model) => {
@@ -523,6 +676,111 @@ export class RoutedSession {
             return useFastTier ? withFastServiceTier(nextPayload) : nextPayload;
         };
     }
+    observeProviderResponseEvent(event, activeEventId) {
+        if (!event || typeof event !== "object")
+            return;
+        if (activeEventId && this.activeMessage?.id !== activeEventId)
+            return;
+        const candidate = event;
+        if (providerResponseCompleted(candidate)) {
+            this.flushPendingProviderWebSearchFinishes();
+            return;
+        }
+        this.emitProviderWebSearchEvent(candidate, undefined, "provider");
+    }
+    emitProviderWebSearchEvent(candidate, normalized = normalizeProviderWebSearchEvent(this.piboSessionId, candidate), source = "provider") {
+        if (!normalized || (normalized.type !== "tool_execution_started" &&
+            normalized.type !== "tool_execution_updated" &&
+            normalized.type !== "tool_execution_finished"))
+            return false;
+        const lifecycle = this.providerWebSearchLifecycle.get(normalized.toolCallId) ?? { started: false, finished: false };
+        if (source === "provider")
+            lifecycle.providerObserved = true;
+        else if (lifecycle.providerObserved) {
+            if (normalized.type === "tool_execution_finished" && !lifecycle.finished && !lifecycle.pendingFinish) {
+                lifecycle.pendingFinish = normalized;
+                this.providerWebSearchLifecycle.set(normalized.toolCallId, lifecycle);
+            }
+            return true;
+        }
+        if (normalized.type === "tool_execution_started" || normalized.type === "tool_execution_updated") {
+            if (lifecycle.finished)
+                return true;
+            const argsKey = providerWebSearchArgsKey(normalized.args);
+            if (!lifecycle.started) {
+                lifecycle.started = true;
+                lifecycle.argsKey = argsKey;
+                this.emit(this.withActiveMessage(normalized.type === "tool_execution_started" ? normalized : {
+                    type: "tool_execution_started",
+                    piboSessionId: normalized.piboSessionId,
+                    toolCallId: normalized.toolCallId,
+                    toolName: normalized.toolName,
+                    args: normalized.args,
+                }));
+            }
+            else if (argsKey !== lifecycle.argsKey) {
+                lifecycle.argsKey = argsKey;
+                this.emit(this.withActiveMessage({
+                    type: "tool_execution_updated",
+                    piboSessionId: this.piboSessionId,
+                    toolCallId: normalized.toolCallId,
+                    toolName: normalized.toolName,
+                    args: normalized.args,
+                    partialResult: normalized.args,
+                }));
+            }
+            this.providerWebSearchLifecycle.set(normalized.toolCallId, lifecycle);
+            return true;
+        }
+        if (providerWebSearchCompletionIsProvisional(candidate) || (source === "pi" && this.providerWebSearchObservationEnabled)) {
+            if (!lifecycle.started) {
+                const args = providerWebSearchArgsFromResult(normalized.result);
+                lifecycle.started = true;
+                lifecycle.argsKey = providerWebSearchArgsKey(args);
+                this.emit(this.withActiveMessage({
+                    type: "tool_execution_started",
+                    piboSessionId: this.piboSessionId,
+                    toolCallId: normalized.toolCallId,
+                    toolName: normalized.toolName,
+                    args,
+                }));
+            }
+            lifecycle.pendingFinish = normalized;
+            this.providerWebSearchLifecycle.set(normalized.toolCallId, lifecycle);
+            return true;
+        }
+        if (lifecycle.finished)
+            return true;
+        lifecycle.pendingFinish = undefined;
+        this.finishProviderWebSearchLifecycle(normalized, lifecycle);
+        return true;
+    }
+    finishProviderWebSearchLifecycle(normalized, lifecycle) {
+        if (!lifecycle.started) {
+            const args = providerWebSearchArgsFromResult(normalized.result);
+            lifecycle.started = true;
+            lifecycle.argsKey = providerWebSearchArgsKey(args);
+            this.emit(this.withActiveMessage({
+                type: "tool_execution_started",
+                piboSessionId: this.piboSessionId,
+                toolCallId: normalized.toolCallId,
+                toolName: normalized.toolName,
+                args,
+            }));
+        }
+        lifecycle.finished = true;
+        this.providerWebSearchLifecycle.set(normalized.toolCallId, lifecycle);
+        this.emit(this.withActiveMessage(normalized));
+    }
+    flushPendingProviderWebSearchFinishes() {
+        for (const lifecycle of this.providerWebSearchLifecycle.values()) {
+            const pending = lifecycle.pendingFinish;
+            if (!pending || lifecycle.finished)
+                continue;
+            lifecycle.pendingFinish = undefined;
+            this.finishProviderWebSearchLifecycle(pending, lifecycle);
+        }
+    }
     shouldUseFastServiceTier(model) {
         if (this.getFastModeResult().mode !== "fast")
             return false;
@@ -576,13 +834,17 @@ export class RoutedSession {
         this.unsubscribe = session.subscribe((event) => {
             this.onPiEventTelemetry?.(this.piboSessionId, event, { status: this.getStatus(), activeEventId: this.activeMessage?.id ?? this.activeExecutionEvent?.id });
             const model = this.runtime.session.model;
-            const normalized = normalizePiEvent(this.piboSessionId, event, {
+            const candidate = event && typeof event === "object" ? event : undefined;
+            const providerWebSearchEvent = candidate ? normalizeProviderWebSearchEvent(this.piboSessionId, candidate) : undefined;
+            const normalized = providerWebSearchEvent ?? normalizePiEvent(this.piboSessionId, event, {
                 contextWindow: numberValue(model?.contextWindow),
                 intentTracing: piIntentTracingInstalled(session),
                 intentFieldForTool: (toolName) => piToolIntentField(session, toolName),
             });
-            const candidate = event && typeof event === "object" ? event : undefined;
             const assistantMessageEnded = candidate?.type === "message_end" && isAssistantMessage(candidate.message);
+            const assistantMessageFailed = assistantMessageEnded && normalized?.type === "session_error";
+            if (assistantMessageEnded && !assistantMessageFailed)
+                this.flushPendingProviderWebSearchFinishes();
             const usageEvent = assistantMessageEnded ? normalizeAssistantUsageEvent(this.piboSessionId, candidate?.message) : undefined;
             if (usageEvent)
                 this.emit(this.withActiveMessage(usageEvent));
@@ -597,8 +859,18 @@ export class RoutedSession {
                     this.pendingAssistantError = undefined;
                     this.pendingAssistantErrorRetryable = false;
                 }
-                if (normalized)
+                const nativeProviderWebSearchEvent = this.providerWebSearchObservationEnabled
+                    ? normalizeNativeProviderWebSearchEvent(normalized)
+                    : undefined;
+                if (providerWebSearchEvent && candidate) {
+                    this.emitProviderWebSearchEvent(candidate, providerWebSearchEvent, "provider");
+                }
+                else if (nativeProviderWebSearchEvent && candidate) {
+                    this.emitProviderWebSearchEvent(candidate, nativeProviderWebSearchEvent, "pi");
+                }
+                else if (normalized) {
                     this.emit(this.withActiveMessage(normalized));
+                }
             }
             if (this.forwardPiEvents) {
                 this.emit({ type: "pi_event", piboSessionId: this.piboSessionId, event });
@@ -762,6 +1034,9 @@ export class RoutedSession {
     }
     enqueueMessage(event) {
         this.assertActive();
+        if (this.sessionIdentityOperationInFlight) {
+            throw new Error("Pibo session cannot accept messages while a session identity operation is in progress.");
+        }
         this.queue.push({ kind: "message", event });
         const output = {
             type: "message_queued",
@@ -807,18 +1082,29 @@ export class RoutedSession {
         if (event.action === "compact") {
             return this.enqueueCompactAction(event);
         }
-        const result = await this.runAction(event);
-        if (isSessionOperationResult(result))
-            await this.onSessionOperation?.(result, event);
-        const output = {
-            type: "execution_result",
-            piboSessionId: this.piboSessionId,
-            eventId: event.id,
-            action: event.action,
-            result,
-        };
-        this.emit(output);
-        return output;
+        const changesSessionIdentity = event.action === "session.fork" || event.action === "session.clone";
+        if (changesSessionIdentity) {
+            this.assertSessionIdentityOperationIdle(event.action === "session.fork" ? "fork" : "clone");
+            this.sessionIdentityOperationInFlight = true;
+        }
+        try {
+            const result = await this.runAction(event);
+            if (isSessionOperationResult(result))
+                await this.onSessionOperation?.(result, event);
+            const output = {
+                type: "execution_result",
+                piboSessionId: this.piboSessionId,
+                eventId: event.id,
+                action: event.action,
+                result,
+            };
+            this.emit(output);
+            return output;
+        }
+        finally {
+            if (changesSessionIdentity)
+                this.sessionIdentityOperationInFlight = false;
+        }
     }
     getActiveMessage() {
         if (!this.activeMessage)
@@ -919,10 +1205,12 @@ export class RoutedSession {
         }));
     }
     getForkCandidates() {
+        this.assertSessionIdentityOperationIdle("inspect fork candidates");
         return this.runtime.session.getUserMessagesForForking();
     }
     async forkSession(entryId) {
         this.assertActive();
+        this.assertSessionWorkIdle("fork");
         const previous = this.createSessionSnapshot();
         const result = await this.runtime.fork(entryId);
         return {
@@ -935,6 +1223,7 @@ export class RoutedSession {
     }
     async cloneSession() {
         this.assertActive();
+        this.assertSessionWorkIdle("clone");
         const leafId = this.runtime.session.sessionManager.getLeafId();
         if (!leafId) {
             throw new Error("Cannot clone session: no current entry selected");
@@ -948,6 +1237,18 @@ export class RoutedSession {
             cancelled: result.cancelled,
         };
     }
+    assertSessionIdentityOperationIdle(operation) {
+        if (this.sessionIdentityOperationInFlight) {
+            throw new Error(`Pibo session already has a session identity operation in progress; cannot ${operation}.`);
+        }
+        this.assertSessionWorkIdle(operation);
+    }
+    assertSessionWorkIdle(operation) {
+        const status = this.getStatus();
+        if (status.processing || status.streaming || status.queuedMessages > 0) {
+            throw new Error(`Pibo session must be idle to ${operation}.`);
+        }
+    }
     getSessionTree() {
         this.assertActive();
         return {
@@ -1151,8 +1452,11 @@ export class RoutedSession {
         const drain = this.drain();
         this.drainPromise = drain;
         void drain.finally(() => {
-            if (this.drainPromise === drain)
-                this.drainPromise = undefined;
+            if (this.drainPromise !== drain)
+                return;
+            this.drainPromise = undefined;
+            if (this.queue.length > 0 && !this.disposed)
+                this.startDrain();
         });
     }
     async drain() {
@@ -1205,6 +1509,7 @@ export class RoutedSession {
             if (this.disposed || inFlight.cancelled)
                 return;
             this.activeMessage = event;
+            this.providerWebSearchLifecycle.clear();
             this.providerRecoveryCancelled = false;
             this.pendingAssistantError = undefined;
             this.pendingAssistantErrorRetryable = false;
@@ -1239,6 +1544,7 @@ export class RoutedSession {
                 return;
             this.flushPendingAssistantError();
             if (!this.activeMessageFailed) {
+                this.flushPendingProviderWebSearchFinishes();
                 this.emit({
                     type: "message_finished",
                     piboSessionId: this.piboSessionId,
@@ -1272,6 +1578,7 @@ export class RoutedSession {
             this.nextAssistantIndex = 0;
             this.activeThinkingIndex = undefined;
             this.nextThinkingIndex = 0;
+            this.providerWebSearchLifecycle.clear();
             if (this.inFlightMessage === inFlight)
                 this.inFlightMessage = undefined;
             inFlight.resolveSettled();

package/dist/apps/chat/agent-store.js

@@ -793,6 +793,9 @@ function sanitizeSubagents(value) {
         const thinkingLevel = sanitizeThinkingLevel(candidate.thinkingLevel);
         if (thinkingLevel)
             subagent.thinkingLevel = thinkingLevel;
+        if (candidate.runtimeOptions && typeof candidate.runtimeOptions === "object" && !Array.isArray(candidate.runtimeOptions)) {
+            subagent.runtimeOptions = structuredClone(candidate.runtimeOptions);
+        }
         if (typeof candidate.timeoutMs === "number")
             subagent.timeoutMs = candidate.timeoutMs;
         if (typeof candidate.maxDepth === "number")

package/dist/apps/chat/chat-api-routes.js

@@ -314,7 +314,7 @@ export function sessionActionResource(pathname) {
     if (parts.length !== 2 || !parts[0])
         return undefined;
     const action = parts[1];
-    if (action !== "read" && action !== "kill" && action !== "kill-all" && action !== "runtime-binding")
+    if (action !== "read" && action !== "kill" && action !== "kill-all" && action !== "runtime-binding" && action !== "fork-candidates")
         return undefined;
     try {
         return { piboSessionId: decodeURIComponent(parts[0]), action };