@copilotkit/channels-core 0.4.1-canary.perfall1 → 0.5.0

package/dist/thread.js

@@ -2,6 +2,14 @@ import { runAgentLoop } from "./run-loop.js";
 import { errorClass, normalizePlatform } from "./telemetry/sanitize-error.js";
 import { toAgentToolDescriptors } from "./tools.js";
 import { validateSchema } from "./standard-schema.js";
+/** Stable rejection for surfaces that cannot hold one run open for a choice. */
+class ChannelAwaitChoiceNotSupportedError extends Error {
+    code = "channel_await_choice_not_supported";
+    constructor() {
+        super("Managed Channels v1 does not support Thread.awaitChoice(); post the picker in an onInterrupt handler and call Thread.resume() from the later interaction delivery.");
+        this.name = "ChannelAwaitChoiceNotSupportedError";
+    }
+}
 /** A concrete conversation thread: posts UI, runs the agent loop, and resolves HITL waiters. */
 export class Thread {
     deps;
@@ -11,9 +19,10 @@ export class Thread {
     /** Mirrors the adapter's `supportsBlockingChoice` capability (see SurfaceCapabilities). */
     supportsBlockingChoice;
     store;
+    implicitInboundConsumed = false;
     constructor(deps) {
         this.deps = deps;
-        this.platform = deps.adapter.platform;
+        this.platform = deps.platform ?? deps.adapter.platform;
         this.conversationKey = deps.conversationKey;
         this.supportsBlockingChoice =
             deps.adapter.capabilities.supportsBlockingChoice;
@@ -22,6 +31,17 @@ export class Thread {
     async bindForPost(ui) {
         return this.deps.registry.bindRenderable(ui, this.deps.conversationKey);
     }
+    trackOperation(operation) {
+        if (!this.deps.adapter.trackThreadOperation) {
+            try {
+                return operation();
+            }
+            catch (error) {
+                return Promise.reject(error);
+            }
+        }
+        return this.deps.adapter.trackThreadOperation(this.deps.replyTarget, operation);
+    }
     /**
      * Wire a posted message's `onReaction` to its returned id: cache it for this
      * process and, when it came from a component, persist a durable snapshot so a
@@ -38,301 +58,376 @@ export class Thread {
             });
         }
     }
-    async post(ui) {
-        const bound = await this.bindForPost(ui);
-        const ref = await this.deps.adapter.post(this.deps.replyTarget, bound.root);
-        await this.bindReaction(ref.id, bound);
-        return ref;
+    post(ui) {
+        return this.trackOperation(async () => {
+            const bound = await this.bindForPost(ui);
+            const ref = await this.deps.adapter.post(this.deps.replyTarget, bound.root);
+            await this.bindReaction(ref.id, bound);
+            return ref;
+        });
     }
-    async update(ref, ui) {
-        const bound = await this.bindForPost(ui);
-        await this.deps.adapter.update(ref, bound.root);
-        await this.bindReaction(ref.id, bound);
-        return ref;
+    update(ref, ui) {
+        return this.trackOperation(async () => {
+            const bound = await this.bindForPost(ui);
+            await this.deps.adapter.update(ref, bound.root);
+            await this.bindReaction(ref.id, bound);
+            return ref;
+        });
     }
-    async delete(ref) {
-        await this.deps.adapter.delete(ref);
+    delete(ref) {
+        return this.trackOperation(() => this.deps.adapter.delete(ref));
     }
-    async stream(src) {
-        const iter = typeof src === "string"
-            ? (async function* () {
-                yield src;
-            })()
-            : src;
-        return this.deps.adapter.stream(this.deps.replyTarget, iter);
+    stream(src) {
+        return this.trackOperation(() => {
+            const iter = typeof src === "string"
+                ? (async function* () {
+                    yield src;
+                })()
+                : src;
+            return this.deps.adapter.stream(this.deps.replyTarget, iter);
+        });
     }
-    async postFile(args) {
-        const adapter = this.deps.adapter;
-        if (!adapter.postFile) {
-            return {
-                ok: false,
-                error: `${this.platform} does not support file upload`,
-            };
-        }
-        return adapter.postFile(this.deps.replyTarget, args);
+    postFile(args) {
+        return this.trackOperation(async () => {
+            const adapter = this.deps.adapter;
+            if (!adapter.postFile) {
+                return {
+                    ok: false,
+                    error: `${this.platform} does not support file upload`,
+                };
+            }
+            return adapter.postFile(this.deps.replyTarget, args);
+        });
     }
     /** Pin suggested prompts (returns `{ ok: false }` on surfaces without support). */
-    async setSuggestedPrompts(prompts, opts) {
-        const adapter = this.deps.adapter;
-        if (!adapter.setSuggestedPrompts) {
-            return {
-                ok: false,
-                error: `${this.platform} does not support suggested prompts`,
-            };
-        }
-        return adapter.setSuggestedPrompts(this.deps.replyTarget, prompts, opts);
+    setSuggestedPrompts(prompts, opts) {
+        return this.trackOperation(async () => {
+            const adapter = this.deps.adapter;
+            if (!adapter.setSuggestedPrompts) {
+                return {
+                    ok: false,
+                    error: `${this.platform} does not support suggested prompts`,
+                };
+            }
+            return adapter.setSuggestedPrompts(this.deps.replyTarget, prompts, opts);
+        });
     }
     /** Name this conversation (returns `{ ok: false }` on surfaces without support). */
-    async setTitle(title) {
-        const adapter = this.deps.adapter;
-        if (!adapter.setThreadTitle) {
-            return {
-                ok: false,
-                error: `${this.platform} does not support thread titles`,
-            };
-        }
-        return adapter.setThreadTitle(this.deps.replyTarget, title);
+    setTitle(title) {
+        return this.trackOperation(async () => {
+            const adapter = this.deps.adapter;
+            if (!adapter.setThreadTitle) {
+                return {
+                    ok: false,
+                    error: `${this.platform} does not support thread titles`,
+                };
+            }
+            return adapter.setThreadTitle(this.deps.replyTarget, title);
+        });
     }
     /** Add an emoji reaction to a message (capability-gated; `{ ok: false }` on surfaces without support). */
-    async react(messageRef, emoji) {
-        const adapter = this.deps.adapter;
-        if (!adapter.addReaction) {
-            return {
-                ok: false,
-                error: `${this.platform} does not support reactions`,
-            };
-        }
-        return adapter.addReaction(this.deps.replyTarget, messageRef, emoji);
+    react(messageRef, emoji) {
+        return this.trackOperation(async () => {
+            const adapter = this.deps.adapter;
+            if (!adapter.addReaction) {
+                return {
+                    ok: false,
+                    error: `${this.platform} does not support reactions`,
+                };
+            }
+            return adapter.addReaction(this.deps.replyTarget, messageRef, emoji);
+        });
     }
     /** Remove the channel's emoji reaction from a message (capability-gated). */
-    async unreact(messageRef, emoji) {
-        const adapter = this.deps.adapter;
-        if (!adapter.removeReaction) {
-            return {
-                ok: false,
-                error: `${this.platform} does not support reactions`,
-            };
-        }
-        return adapter.removeReaction(this.deps.replyTarget, messageRef, emoji);
+    unreact(messageRef, emoji) {
+        return this.trackOperation(async () => {
+            const adapter = this.deps.adapter;
+            if (!adapter.removeReaction) {
+                return {
+                    ok: false,
+                    error: `${this.platform} does not support reactions`,
+                };
+            }
+            return adapter.removeReaction(this.deps.replyTarget, messageRef, emoji);
+        });
     }
     /**
      * Post a message only `user` can see. `fallbackToDM` is required:
      * `true` → DM the user when native ephemeral is unsupported; `false` →
      * resolve to `null` when native ephemeral is unsupported.
      */
-    async postEphemeral(user, ui, opts) {
-        const adapter = this.deps.adapter;
-        if (!adapter.postEphemeral) {
-            return {
-                ok: false,
-                error: `${this.platform} does not support ephemeral messages`,
-            };
-        }
-        // Ephemeral messages can't be reacted to, so any `onReaction` is dropped
-        // (stripped by bindForPost) rather than registered.
-        const { root } = await this.bindForPost(ui);
-        return adapter.postEphemeral(this.deps.replyTarget, user, root, opts);
+    postEphemeral(user, ui, opts) {
+        return this.trackOperation(async () => {
+            const adapter = this.deps.adapter;
+            if (!adapter.postEphemeral) {
+                return {
+                    ok: false,
+                    error: `${this.platform} does not support ephemeral messages`,
+                };
+            }
+            // Ephemeral messages can't be reacted to, so any `onReaction` is dropped
+            // (stripped by bindForPost) rather than registered.
+            const { root } = await this.bindForPost(ui);
+            return adapter.postEphemeral(this.deps.replyTarget, user, root, opts);
+        });
     }
     // Subscription STORAGE lands here; subscription ROUTING (onSubscribedMessage) is deferred.
     /** Record this conversation as subscribed (persisted in state). Proactive delivery to subscribed conversations is not yet wired. */
-    async subscribe() {
-        await this.store.kv.set(`sub:${this.deps.conversationKey}`, true);
+    subscribe() {
+        return this.trackOperation(() => this.store.kv.set(`sub:${this.deps.conversationKey}`, true));
     }
     /** Remove the subscription for this conversation. */
-    async unsubscribe() {
-        await this.store.kv.delete(`sub:${this.deps.conversationKey}`);
+    unsubscribe() {
+        return this.trackOperation(() => this.store.kv.delete(`sub:${this.deps.conversationKey}`));
     }
     /** Returns true if this conversation is currently subscribed. */
-    async isSubscribed() {
-        return ((await this.store.kv.get(`sub:${this.deps.conversationKey}`)) ===
-            true);
+    isSubscribed() {
+        return this.trackOperation(async () => (await this.store.kv.get(`sub:${this.deps.conversationKey}`)) === true);
     }
     /** Persist arbitrary per-thread state (e.g. workflow step). */
-    async setState(v) {
-        let value = v;
-        if (this.deps.stateSchema) {
-            const r = await validateSchema(this.deps.stateSchema, v);
-            if (!r.ok)
-                throw new Error(`thread.setState: invalid state — ${r.error}`);
-            value = r.value;
-        }
-        await this.store.kv.set(`threadstate:${this.deps.conversationKey}`, value);
+    setState(v) {
+        return this.trackOperation(async () => {
+            let value = v;
+            if (this.deps.stateSchema) {
+                const r = await validateSchema(this.deps.stateSchema, v);
+                if (!r.ok)
+                    throw new Error(`thread.setState: invalid state — ${r.error}`);
+                value = r.value;
+            }
+            await this.store.kv.set(`threadstate:${this.deps.conversationKey}`, value);
+        });
     }
     /** Read back per-thread state previously written with `setState`. */
-    async state() {
-        return this.store.kv.get(`threadstate:${this.deps.conversationKey}`);
+    state() {
+        return this.trackOperation(() => this.store.kv.get(`threadstate:${this.deps.conversationKey}`));
     }
     /** Read the conversation's messages (returns `[]` when the adapter can't read history). */
-    async getMessages() {
-        return (await this.deps.adapter.getMessages?.(this.deps.replyTarget)) ?? [];
+    getMessages() {
+        return this.trackOperation(async () => (await this.deps.adapter.getMessages?.(this.deps.replyTarget)) ?? []);
     }
     /** Resolve a platform user by free-form query (returns `undefined` when unsupported). */
-    async lookupUser(query) {
-        return this.deps.adapter.lookupUser?.({ query });
+    lookupUser(query) {
+        return this.trackOperation(() => this.deps.adapter.lookupUser({ query }));
     }
     /** Post a picker and wait until an interaction in this conversation resolves it. */
-    async awaitChoice(ui) {
-        const p = new Promise((resolve) => this.deps.registerWaiter(this.deps.conversationKey, resolve));
-        await this.post(ui);
-        return p;
+    awaitChoice(ui) {
+        if (this.supportsBlockingChoice === false) {
+            return Promise.reject(new ChannelAwaitChoiceNotSupportedError());
+        }
+        return this.trackOperation(async () => {
+            const p = new Promise((resolve) => this.deps.registerWaiter(this.deps.conversationKey, resolve));
+            await this.post(ui);
+            return p;
+        });
     }
-    async runAgent(input) {
-        const message = this.deps.message;
-        const defaultPrompt = message?.contentParts && message.contentParts.length > 0
-            ? message.contentParts
-            : message?.text;
-        return this.run(undefined, {
-            ...input,
-            prompt: input?.prompt ??
-                (this.deps.adapter.conversationStore.seedsInboundTurn
-                    ? undefined
-                    : defaultPrompt),
+    runAgent(input) {
+        try {
+            this.deps.adapter.assertRunAgentSupported?.(this.deps.replyTarget);
+        }
+        catch (error) {
+            return Promise.reject(error);
+        }
+        return this.trackOperation(async () => {
+            const message = this.deps.message;
+            const defaultPrompt = message?.contentParts && message.contentParts.length > 0
+                ? message.contentParts
+                : message?.text;
+            const implicitPrompt = input?.prompt === undefined &&
+                !this.deps.adapter.conversationStore.seedsInboundTurn &&
+                (!this.deps.adapter.injectInboundTurnOnce ||
+                    !this.implicitInboundConsumed);
+            if (implicitPrompt && defaultPrompt) {
+                this.implicitInboundConsumed = true;
+            }
+            return this.run(undefined, {
+                ...input,
+                prompt: input?.prompt ?? (!implicitPrompt ? undefined : defaultPrompt),
+            });
         });
     }
-    async resume(value) {
-        return this.run({ resume: value });
+    resume(value) {
+        return this.trackOperation(() => this.run({ resume: value }));
     }
     async run(initialResume, extra) {
         const session = await this.deps.adapter.conversationStore.getOrCreate(this.deps.conversationKey, this.deps.replyTarget, this.deps.agentFactory);
-        // Inject an explicit user message when the input isn't in the adapter's
-        // reconstructed history (e.g. a slash command's args, or inbound image/file
-        // attachments built into multimodal content parts). A non-empty array is
-        // truthy, so this guard also admits multimodal prompts.
-        if (extra?.prompt) {
-            session.agent.addMessage({
-                id: globalThis.crypto.randomUUID(),
-                role: "user",
-                // AG-UI types `content` as `string`, but multimodal works at runtime by
-                // setting it to an `AgentContentPart[]` — the runtime's LLM adapter
-                // converts the parts to the provider's multimodal format. We cast to
-                // satisfy the string-typed field (channels-slack parity — it does the same
-                // when assigning multimodal `content` to its reconstructed messages).
-                content: extra.prompt,
-            });
-        }
-        const renderer = this.deps.adapter.createRunRenderer(this.deps.replyTarget);
-        // Transcript auto-bridge (step 1 + 2): inject prior cross-platform history
-        // as a context entry, then append the current user turn. This flag owns the
-        // bridge — see `runAgent`'s `transcript` doc. No-ops with one warning when
-        // identity/transcripts aren't configured.
-        const transcripts = this.deps.transcripts;
-        const userKey = this.deps.userKey;
-        let transcriptContext;
-        if (extra?.transcript) {
-            if (transcripts && userKey) {
-                const limit = typeof extra.transcript === "object"
-                    ? (extra.transcript.limit ?? 20)
-                    : 20;
-                // List BEFORE appending the current user turn so the current message
-                // isn't counted as its own "prior history".
-                const prior = await transcripts.list({ userKey, limit });
-                if (prior.length > 0) {
-                    transcriptContext = {
-                        description: `Prior cross-platform conversation history with this user. Current channel: ${this.platform}.`,
-                        value: prior
-                            .map((e) => `[${e.platform}] ${e.role}: ${e.text}`)
-                            .join("\n"),
-                    };
+        try {
+            // Inject an explicit user message when the input isn't in the adapter's
+            // reconstructed history (e.g. a slash command's args, or inbound image/file
+            // attachments built into multimodal content parts). A non-empty array is
+            // truthy, so this guard also admits multimodal prompts.
+            const promptAlreadySeeded = this.deps.adapter.conversationStore.seedsInboundTurn &&
+                promptMatchesInbound(extra?.prompt, this.deps.message);
+            if (extra?.prompt && !promptAlreadySeeded) {
+                session.agent.addMessage({
+                    id: globalThis.crypto.randomUUID(),
+                    role: "user",
+                    // AG-UI types `content` as `string`, but multimodal works at runtime by
+                    // setting it to an `AgentContentPart[]` — the runtime's LLM adapter
+                    // converts the parts to the provider's multimodal format. We cast to
+                    // satisfy the string-typed field (channels-slack parity — it does the same
+                    // when assigning multimodal `content` to its reconstructed messages).
+                    content: extra.prompt,
+                });
+            }
+            const renderer = this.deps.adapter.createRunRenderer(this.deps.replyTarget);
+            // Transcript auto-bridge (step 1 + 2): inject prior cross-platform history
+            // as a context entry, then append the current user turn. This flag owns the
+            // bridge — see `runAgent`'s `transcript` doc. No-ops with one warning when
+            // identity/transcripts aren't configured.
+            const transcripts = this.deps.transcripts;
+            const userKey = this.deps.userKey;
+            let transcriptContext;
+            if (extra?.transcript) {
+                if (transcripts && userKey) {
+                    const limit = typeof extra.transcript === "object"
+                        ? (extra.transcript.limit ?? 20)
+                        : 20;
+                    // List BEFORE appending the current user turn so the current message
+                    // isn't counted as its own "prior history".
+                    const prior = await transcripts.list({ userKey, limit });
+                    if (prior.length > 0) {
+                        transcriptContext = {
+                            description: `Prior cross-platform conversation history with this user. Current channel: ${this.platform}.`,
+                            value: prior
+                                .map((e) => `[${e.platform}] ${e.role}: ${e.text}`)
+                                .join("\n"),
+                        };
+                    }
+                    if (this.deps.message) {
+                        await transcripts.append(this, this.deps.message, { userKey });
+                    }
                 }
-                if (this.deps.message) {
-                    await transcripts.append(this, this.deps.message, { userKey });
+                else {
+                    warnTranscriptIgnored();
                 }
             }
-            else {
-                warnTranscriptIgnored();
+            // Merge per-run context/tools (this run only) on top of the channel-level deps.
+            const extraTools = extra?.tools ?? [];
+            let tools = this.deps.tools;
+            let toolDescriptors = this.deps.toolDescriptors;
+            if (extraTools.length > 0) {
+                tools = new Map(this.deps.tools);
+                for (const t of extraTools)
+                    tools.set(t.name, t);
+                toolDescriptors = [
+                    ...this.deps.toolDescriptors,
+                    ...toAgentToolDescriptors(extraTools),
+                ];
             }
-        }
-        // Merge per-run context/tools (this run only) on top of the channel-level deps.
-        const extraTools = extra?.tools ?? [];
-        let tools = this.deps.tools;
-        let toolDescriptors = this.deps.toolDescriptors;
-        if (extraTools.length > 0) {
-            tools = new Map(this.deps.tools);
-            for (const t of extraTools)
-                tools.set(t.name, t);
-            toolDescriptors = [
-                ...this.deps.toolDescriptors,
-                ...toAgentToolDescriptors(extraTools),
+            const context = [
+                ...this.deps.context,
+                ...(transcriptContext ? [transcriptContext] : []),
+                ...(extra?.context ?? []),
             ];
-        }
-        const context = [
-            ...this.deps.context,
-            ...(transcriptContext ? [transcriptContext] : []),
-            ...(extra?.context ?? []),
-        ];
-        // Snapshot the message count BEFORE the loop so we can isolate the
-        // assistant messages this run produced (step 4).
-        const messagesBefore = session.agent.messages.length;
-        const startedAt = Date.now();
-        let loopResult;
-        // Telemetry stage: "agent" while the run loop runs, "finalize" for the
-        // transcript-append + renderer.finish() steps below. A throw in either is
-        // reported as agent_run_failed (with the right stage) instead of being
-        // hidden behind an already-sent success event.
-        let stage = "agent";
-        try {
-            loopResult = await runAgentLoop({
-                agent: session.agent,
-                renderer,
-                tools,
-                toolDescriptors,
-                context,
-                makeToolCtx: () => ({
-                    thread: this,
-                    platform: this.platform,
-                }),
-                handleInterrupt: async (interrupt) => {
-                    const h = this.deps.interruptHandlers.get(interrupt.eventName);
-                    if (h)
-                        await h({ payload: interrupt.value, thread: this });
-                },
-                initialResume,
-            });
-            stage = "finalize";
-            // Transcript auto-bridge (step 4): capture the assistant text this run
-            // produced and append it. Only when the bridge actually applied (transcripts
-            // + userKey both present and `transcript` was requested).
-            if (extra?.transcript && transcripts && userKey) {
-                const produced = session.agent.messages.slice(messagesBefore);
-                const text = produced
-                    .filter((m) => m.role === "assistant" &&
-                    typeof m.content === "string" &&
-                    m.content.trim().length > 0)
-                    .map((m) => m.content)
-                    .join("\n\n");
-                if (text.length > 0) {
-                    await transcripts.append(this, { role: "assistant", text }, { userKey });
+            // Snapshot the message count BEFORE the loop so we can isolate the
+            // assistant messages this run produced (step 4).
+            const messagesBefore = session.agent.messages.length;
+            const startedAt = Date.now();
+            let loopResult;
+            // Telemetry stage: "agent" while the run loop runs, "finalize" for the
+            // transcript-append + renderer.finish() steps below. A throw in either is
+            // reported as agent_run_failed (with the right stage) instead of being
+            // hidden behind an already-sent success event.
+            let stage = "agent";
+            try {
+                const loopArgs = {
+                    agent: session.agent,
+                    renderer,
+                    tools,
+                    toolDescriptors,
+                    context,
+                    makeToolCtx: () => ({
+                        thread: this,
+                        platform: this.platform,
+                    }),
+                    handleInterrupt: async (interrupt) => {
+                        const h = this.deps.interruptHandlers.get(interrupt.eventName);
+                        if (h)
+                            await h({ payload: interrupt.value, thread: this });
+                    },
+                    initialResume,
+                };
+                loopResult = this.deps.adapter.runAgentLifecycle
+                    ? await this.deps.adapter.runAgentLifecycle({
+                        replyTarget: this.deps.replyTarget,
+                        agent: session.agent,
+                        renderer,
+                        tools: toolDescriptors,
+                        context,
+                        isResume: initialResume !== undefined,
+                        execute: (subscriber, canonicalRun) => runAgentLoop({
+                            ...loopArgs,
+                            subscriber,
+                            ...(canonicalRun ? { canonicalRun } : {}),
+                        }),
+                    })
+                    : await runAgentLoop(loopArgs);
+                stage = "finalize";
+                // Transcript auto-bridge (step 4): capture the assistant text this run
+                // produced and append it. Only when the bridge actually applied (transcripts
+                // + userKey both present and `transcript` was requested).
+                if (extra?.transcript && transcripts && userKey) {
+                    const produced = session.agent.messages.slice(messagesBefore);
+                    const text = produced
+                        .filter((m) => m.role === "assistant" &&
+                        typeof m.content === "string" &&
+                        m.content.trim().length > 0)
+                        .map((m) => m.content)
+                        .join("\n\n");
+                    if (text.length > 0) {
+                        await transcripts.append(this, { role: "assistant", text }, { userKey });
+                    }
                 }
+                // Turn-end hook: lets a renderer finalize any turn-scoped resource it kept
+                // open across runAgent iterations (e.g. a native streaming message). A
+                // no-op for renderers whose per-message streams already self-terminate, and
+                // for runs that were interrupted (the renderer guards that internally).
+                await renderer.finish?.();
             }
-            // Turn-end hook: lets a renderer finalize any turn-scoped resource it kept
-            // open across runAgent iterations (e.g. a native streaming message). A
-            // no-op for renderers whose per-message streams already self-terminate, and
-            // for runs that were interrupted (the renderer guards that internally).
-            await renderer.finish?.();
-        }
-        catch (err) {
-            // A throw is a run failure — in the agent loop (tool-handler errors are
-            // swallowed inside the loop, so a throw is agent-level) or in finalization.
-            // `stage` distinguishes the two.
-            this.deps.telemetry?.capture("oss.channel.agent_run_failed", {
+            catch (err) {
+                // Best-effort finalize on failure so native Slack streams still get
+                // stopStream after mid-run delivery/append errors (deferred deliveryError
+                // or run-loop throw). finish is idempotent; original error wins.
+                try {
+                    await renderer.finish?.();
+                }
+                catch {
+                    // Prefer the original failure over finalize noise.
+                }
+                // A throw is a run failure — in the agent loop (tool-handler errors are
+                // swallowed inside the loop, so a throw is agent-level) or in finalization.
+                // `stage` distinguishes the two.
+                this.deps.telemetry?.capture("oss.channel.agent_run_failed", {
+                    platform: normalizePlatform(this.platform),
+                    errorClass: errorClass(err),
+                    stage,
+                });
+                throw err;
+            }
+            // Emit success ONLY after the loop AND finalization both completed, so a
+            // late transcript/finish rejection can never follow a success event.
+            this.deps.telemetry?.capture("oss.channel.agent_run", {
                 platform: normalizePlatform(this.platform),
-                errorClass: errorClass(err),
-                stage,
+                durationMs: Date.now() - startedAt,
+                toolCallCount: renderer.getCapturedToolCalls().length,
+                iterations: loopResult.iterations,
+                interrupted: loopResult.interrupted,
             });
-            throw err;
+            return undefined;
+        }
+        finally {
+            await session.release?.();
         }
-        // Emit success ONLY after the loop AND finalization both completed, so a
-        // late transcript/finish rejection can never follow a success event.
-        this.deps.telemetry?.capture("oss.channel.agent_run", {
-            platform: normalizePlatform(this.platform),
-            durationMs: Date.now() - startedAt,
-            toolCallCount: renderer.getCapturedToolCalls().length,
-            iterations: loopResult.iterations,
-            interrupted: loopResult.interrupted,
-        });
-        return undefined;
     }
 }
+function promptMatchesInbound(prompt, message) {
+    if (prompt === undefined || message === undefined)
+        return false;
+    if (typeof prompt === "string")
+        return prompt === message.text;
+    return (message.contentParts !== undefined &&
+        JSON.stringify(prompt) === JSON.stringify(message.contentParts));
+}
 let transcriptWarned = false;
 /** Warn once when `runAgent({ transcript })` is used without identity/transcripts configured. */
 function warnTranscriptIgnored() {