@copilotkit/channels-core 0.4.1-canary.1785375021 → 0.4.1-canary.narrowinstall1

package/dist/thread.js

@@ -2,14 +2,6 @@ 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;
@@ -19,10 +11,9 @@ export class Thread {
     /** Mirrors the adapter's `supportsBlockingChoice` capability (see SurfaceCapabilities). */
     supportsBlockingChoice;
     store;
-    implicitInboundConsumed = false;
     constructor(deps) {
         this.deps = deps;
-        this.platform = deps.platform ?? deps.adapter.platform;
+        this.platform = deps.adapter.platform;
         this.conversationKey = deps.conversationKey;
         this.supportsBlockingChoice =
             deps.adapter.capabilities.supportsBlockingChoice;
@@ -31,17 +22,6 @@ 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
@@ -58,355 +38,299 @@ export class Thread {
             });
         }
     }
-    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 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;
     }
-    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 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;
     }
-    delete(ref) {
-        return this.trackOperation(() => this.deps.adapter.delete(ref));
+    async delete(ref) {
+        await this.deps.adapter.delete(ref);
     }
-    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 stream(src) {
+        const iter = typeof src === "string"
+            ? (async function* () {
+                yield src;
+            })()
+            : src;
+        return this.deps.adapter.stream(this.deps.replyTarget, iter);
     }
-    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);
-        });
+    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);
     }
     /** Pin suggested prompts (returns `{ ok: false }` on surfaces without support). */
-    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);
-        });
+    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);
     }
     /** Name this conversation (returns `{ ok: false }` on surfaces without support). */
-    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);
-        });
+    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);
     }
     /** Add an emoji reaction to a message (capability-gated; `{ ok: false }` on surfaces without support). */
-    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);
-        });
+    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);
     }
     /** Remove the channel's emoji reaction from a message (capability-gated). */
-    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);
-        });
+    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);
     }
     /**
      * 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.
      */
-    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);
-        });
+    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);
     }
     // 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. */
-    subscribe() {
-        return this.trackOperation(() => this.store.kv.set(`sub:${this.deps.conversationKey}`, true));
+    async subscribe() {
+        await this.store.kv.set(`sub:${this.deps.conversationKey}`, true);
     }
     /** Remove the subscription for this conversation. */
-    unsubscribe() {
-        return this.trackOperation(() => this.store.kv.delete(`sub:${this.deps.conversationKey}`));
+    async unsubscribe() {
+        await this.store.kv.delete(`sub:${this.deps.conversationKey}`);
     }
     /** Returns true if this conversation is currently subscribed. */
-    isSubscribed() {
-        return this.trackOperation(async () => (await this.store.kv.get(`sub:${this.deps.conversationKey}`)) === true);
+    async isSubscribed() {
+        return ((await this.store.kv.get(`sub:${this.deps.conversationKey}`)) ===
+            true);
     }
     /** Persist arbitrary per-thread state (e.g. workflow step). */
-    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);
-        });
+    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);
     }
     /** Read back per-thread state previously written with `setState`. */
-    state() {
-        return this.trackOperation(() => this.store.kv.get(`threadstate:${this.deps.conversationKey}`));
+    async state() {
+        return this.store.kv.get(`threadstate:${this.deps.conversationKey}`);
     }
     /** Read the conversation's messages (returns `[]` when the adapter can't read history). */
-    getMessages() {
-        return this.trackOperation(async () => (await this.deps.adapter.getMessages?.(this.deps.replyTarget)) ?? []);
+    async getMessages() {
+        return (await this.deps.adapter.getMessages?.(this.deps.replyTarget)) ?? [];
     }
     /** Resolve a platform user by free-form query (returns `undefined` when unsupported). */
-    lookupUser(query) {
-        return this.trackOperation(() => this.deps.adapter.lookupUser({ query }));
+    async lookupUser(query) {
+        return this.deps.adapter.lookupUser?.({ query });
     }
     /** Post a picker and wait until an interaction in this conversation resolves it. */
-    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 awaitChoice(ui) {
+        const p = new Promise((resolve) => this.deps.registerWaiter(this.deps.conversationKey, resolve));
+        await this.post(ui);
+        return p;
     }
-    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 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),
         });
     }
-    resume(value) {
-        return this.trackOperation(() => this.run({ resume: value }));
+    async resume(value) {
+        return 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);
-        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.
-            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"),
-                        };
-                    }
-                    if (this.deps.message) {
-                        await transcripts.append(this, this.deps.message, { userKey });
-                    }
+        // 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"),
+                    };
                 }
-                else {
-                    warnTranscriptIgnored();
+                if (this.deps.message) {
+                    await transcripts.append(this, this.deps.message, { userKey });
                 }
             }
-            // 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),
-                ];
+            else {
+                warnTranscriptIgnored();
             }
-            const context = [
-                ...this.deps.context,
-                ...(transcriptContext ? [transcriptContext] : []),
-                ...(extra?.context ?? []),
+        }
+        // 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),
             ];
-            // 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 });
-                    }
+        }
+        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 });
                 }
-                // 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", {
-                    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", {
+            // 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", {
                 platform: normalizePlatform(this.platform),
-                durationMs: Date.now() - startedAt,
-                toolCallCount: renderer.getCapturedToolCalls().length,
-                iterations: loopResult.iterations,
-                interrupted: loopResult.interrupted,
+                errorClass: errorClass(err),
+                stage,
             });
-            return undefined;
-        }
-        finally {
-            await session.release?.();
+            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),
+            durationMs: Date.now() - startedAt,
+            toolCallCount: renderer.getCapturedToolCalls().length,
+            iterations: loopResult.iterations,
+            interrupted: loopResult.interrupted,
+        });
+        return undefined;
     }
 }
 let transcriptWarned = false;