@symerian/symi 2.5.8 → 2.6.1

package/dist/plugin-sdk/{reply-Ch4_18FZ.js → reply-QAcAd9ev.js}

@@ -27147,7 +27147,8 @@ const BUILTIN_PROFILES = [
 				"<end_of_turn>"
 			],
 			suppressMonologue: true,
-			hasStructuredThinking: false
+			hasStructuredThinking: false,
+			validateToolArgs: true
 		},
 		promptAdditions: [
 			"CRITICAL OUTPUT RULES:",
@@ -27157,7 +27158,8 @@ const BUILTIN_PROFILES = [
 			"- Do not write verification checklists, self-assessments, or numbered assessment lists after your answer.",
 			"- Do not write 'Verification:', 'Requirements:', 'Status Check:', or 'Everything is correct'.",
 			"- If you need to verify your work, do so before writing your response, not after.",
-			"- Send brief progress updates on long tasks so the user knows you are active."
+			"- Send brief progress updates on long tasks so the user knows you are active.",
+			"- When calling tools, provide arguments as clean values only. Never include <|, |>, or XML-like tags in tool argument values. For exec/bash commands, provide only valid shell syntax."
 		],
 		ui: {
 			badge: "Local",
@@ -27181,7 +27183,8 @@ const BUILTIN_PROFILES = [
 		filters: {
 			stripPatterns: [],
 			suppressMonologue: false,
-			hasStructuredThinking: true
+			hasStructuredThinking: true,
+			validateToolArgs: false
 		},
 		promptAdditions: [],
 		ui: {
@@ -27215,7 +27218,8 @@ const BUILTIN_PROFILES = [
 				"^\\s*<bos>\\s*"
 			],
 			suppressMonologue: true,
-			hasStructuredThinking: false
+			hasStructuredThinking: false,
+			validateToolArgs: true
 		},
 		promptAdditions: [
 			"CRITICAL OUTPUT RULES:",
@@ -27226,7 +27230,8 @@ const BUILTIN_PROFILES = [
 			"- Do not write 'Verification:', 'Requirements:', 'Status Check:', or 'Everything is correct'.",
 			"- If you need to verify your work, do so before writing your response, not after.",
 			"- Keep planning and reasoning internal. Only speak when you have a result or need user input.",
-			"- When working on multi-step tasks, send a brief one-line status update so the user knows you are active."
+			"- When working on multi-step tasks, send a brief one-line status update so the user knows you are active.",
+			"- When calling tools, provide arguments as clean values only. Never include <|, |>, or XML-like tags in tool argument values. For exec/bash commands, provide only valid shell syntax."
 		],
 		ui: {
 			badge: "CoreWeave",
@@ -27254,7 +27259,8 @@ const FALLBACK_PROFILE = {
 	filters: {
 		stripPatterns: [],
 		suppressMonologue: false,
-		hasStructuredThinking: false
+		hasStructuredThinking: false,
+		validateToolArgs: false
 	},
 	promptAdditions: [],
 	ui: {
@@ -27737,6 +27743,19 @@ function stripModelTokensAggressive(text, modelId) {
 	}
 	return result;
 }
+/**
+* Clean residual fragments left after aggressive token stripping.
+* After `<|` and `|>` are removed, orphaned `<`, `"`, `|` can remain
+* at string boundaries (e.g., `<<|"|uname -a` → `<"uname -a`).
+*
+* Conservative: only trims leading junk before what looks like a command,
+* and trailing junk. Does NOT touch content in the middle of the string.
+* Preserves heredoc syntax (`<<EOF`, `<<"EOF"`) via negative lookahead.
+*/
+function cleanResidualTokenFragments(text) {
+	if (!text) return text;
+	return text.replace(/^[<"|]+(?!<[A-Z_])(?=[a-zA-Z0-9/~$.(])/gm, "").replace(/[<"|]+$/gm, "").trim();
+}
 
 //#endregion
 //#region src/agents/output-normalizer.ts
@@ -27822,10 +27841,14 @@ function detectRepetition(text, minBlock) {
 	const searchStart = sampleStart + minBlock;
 	return text.indexOf(sample, searchStart) >= 0;
 }
+function sanitizeStringValue(value, modelId) {
+	const stripped = stripModelTokensAggressive(value, modelId);
+	return isGemmaModel$1(modelId) ? cleanResidualTokenFragments(stripped) : stripped;
+}
 function sanitizeArgs(args, modelId) {
 	const result = {};
-	for (const [key, value] of Object.entries(args)) if (typeof value === "string") result[key] = stripModelTokensAggressive(value, modelId);
-	else if (Array.isArray(value)) result[key] = value.map((item) => typeof item === "string" ? stripModelTokensAggressive(item, modelId) : item && typeof item === "object" ? sanitizeArgs(item, modelId) : item);
+	for (const [key, value] of Object.entries(args)) if (typeof value === "string") result[key] = sanitizeStringValue(value, modelId);
+	else if (Array.isArray(value)) result[key] = value.map((item) => typeof item === "string" ? sanitizeStringValue(item, modelId) : item && typeof item === "object" ? sanitizeArgs(item, modelId) : item);
 	else if (value && typeof value === "object") result[key] = sanitizeArgs(value, modelId);
 	else result[key] = value;
 	return result;
@@ -29909,7 +29932,7 @@ async function recordLoopOutcome(args) {
 	if (!args.ctx?.sessionKey) return;
 	try {
 		const { getDiagnosticSessionState } = await import("./diagnostic-session-state-Wd5tNeQG.js").then((n) => n.n);
-		const { recordToolCallOutcome } = await import("./tool-loop-detection-edmW8ZiF.js");
+		const { recordToolCallOutcome } = await import("./tool-loop-detection-DU5sTIKg.js");
 		recordToolCallOutcome(getDiagnosticSessionState({
 			sessionKey: args.ctx.sessionKey,
 			sessionId: args.ctx?.agentId
@@ -29931,7 +29954,7 @@ async function runBeforeToolCallHook(args) {
 	if (args.ctx?.sessionKey) {
 		const { getDiagnosticSessionState } = await import("./diagnostic-session-state-Wd5tNeQG.js").then((n) => n.n);
 		const { logToolLoopAction } = await import("./diagnostic-mFf4i4G9.js").then((n) => n.n);
-		const { detectToolCallLoop, recordToolCall } = await import("./tool-loop-detection-edmW8ZiF.js");
+		const { detectToolCallLoop, recordToolCall } = await import("./tool-loop-detection-DU5sTIKg.js");
 		const sessionState = getDiagnosticSessionState({
 			sessionKey: args.ctx.sessionKey,
 			sessionId: args.ctx?.agentId
@@ -30202,6 +30225,88 @@ function toClientToolDefinitions(tools, onClientToolCall, hookContext) {
 	});
 }
 
+//#endregion
+//#region src/agents/pi-tools.validate.ts
+/**
+* Tool argument validation — validates that exec/bash commands contain
+* valid shell syntax after model token sanitization.
+*
+* Gated on ModelProfile.filters.validateToolArgs — only active for
+* models known to leak control tokens into structured output (Gemma, Ollama).
+*
+* @module
+*/
+/**
+* Validate that a command string contains extractable valid shell syntax.
+* Returns the cleaned command if valid, or an error reason if not.
+*
+* Does NOT attempt to parse the full shell grammar — just checks for
+* obvious corruption (residual control tokens, empty commands).
+* Preserves heredocs, redirects, pipes, and other legitimate shell syntax.
+*/
+function validateShellCommand(command) {
+	if (!command || !command.trim()) return {
+		valid: false,
+		cleaned: "",
+		reason: "empty command"
+	};
+	let cleaned = cleanResidualTokenFragments(command);
+	if (/(?:^|[^<])<\|/.test(cleaned) || /\|>/.test(cleaned)) {
+		cleaned = cleaned.replace(/<\|[^|>]*(?:\|>)?/g, "").trim();
+		cleaned = cleanResidualTokenFragments(cleaned);
+	}
+	if (!cleaned || !cleaned.trim()) return {
+		valid: false,
+		cleaned: "",
+		reason: "command is empty after removing control tokens"
+	};
+	if (!/[a-zA-Z0-9_/.~-]/.test(cleaned)) return {
+		valid: false,
+		cleaned,
+		reason: "no recognizable shell command found"
+	};
+	return {
+		valid: true,
+		cleaned: cleaned.trim()
+	};
+}
+
+//#endregion
+//#region src/agents/pi-tools.validate-wrapper.ts
+const EXEC_TOOL_NAMES = new Set(["exec", "bash"]);
+/**
+* Wrap tools with argument validation. Only exec/bash tools are validated.
+* Other tools pass through unchanged.
+*
+* Call this AFTER tools are created and the model profile is resolved.
+*/
+function wrapToolsWithArgValidation(tools, profile) {
+	if (!profile.filters?.validateToolArgs) return tools;
+	return tools.map((tool) => wrapToolWithArgValidation(tool));
+}
+/**
+* Wrap a single tool with argument validation for exec/bash commands.
+*/
+function wrapToolWithArgValidation(tool) {
+	const toolName = (tool.name ?? "").toLowerCase().trim();
+	if (!EXEC_TOOL_NAMES.has(toolName)) return tool;
+	const originalExecute = tool.execute;
+	return {
+		...tool,
+		execute(toolCallId, params, ...rest) {
+			const command = params.command ?? params.cmd;
+			if (typeof command !== "string") return originalExecute.call(tool, toolCallId, params, ...rest);
+			const result = validateShellCommand(command);
+			if (!result.valid) return Promise.resolve({ output: `Error: ${result.reason}. The command appears to contain model control tokens. Please provide a clean shell command without any <|, |>, or XML-like tags. Only valid shell syntax is accepted.` });
+			if (result.cleaned !== command) return originalExecute.call(tool, toolCallId, {
+				...params,
+				command: result.cleaned
+			}, ...rest);
+			return originalExecute.call(tool, toolCallId, params, ...rest);
+		}
+	};
+}
+
 //#endregion
 //#region src/agents/plan-mode.ts
 /**
@@ -34281,10 +34386,11 @@ async function runEmbeddedAttempt(params) {
 				await resourceLoader.reload();
 			}
 			const hookRunner = getGlobalHookRunner();
-			const { builtInTools, customTools } = splitSdkTools({
+			const { builtInTools: rawBuiltInTools, customTools } = splitSdkTools({
 				tools,
 				sandboxEnabled: !!sandbox?.enabled
 			});
+			const builtInTools = wrapToolsWithArgValidation(rawBuiltInTools, modelProfile);
 			let clientToolCallDetected = null;
 			const clientToolLoopDetection = resolveToolLoopDetectionConfig({
 				cfg: params.config,
@@ -35832,7 +35938,8 @@ async function runAgentTurn(params) {
 	const cb = params.callbacks;
 	const sessionFile = resolveSessionFilePath(params.sessionId, void 0, { agentId });
 	const profile = resolveModelProfile(params.provider && params.modelId ? `${params.provider}/${params.modelId}` : params.config.agents?.defaults?.model?.primary ?? "", params.config.models?.profiles);
-	const result = await runEmbeddedPiAgent({
+	const toolsUsed = [];
+	const buildInternalParams = (providerOverride, modelOverride) => ({
 		sessionId: params.sessionId,
 		sessionKey: params.sessionKey,
 		agentId,
@@ -35847,14 +35954,28 @@ async function runAgentTurn(params) {
 		extraSystemPrompt: params.extraSystemPrompt,
 		clientTools: params.clientTools,
 		disableTools: params.disableTools,
-		provider: params.provider,
-		model: params.modelId,
+		provider: providerOverride ?? params.provider,
+		model: modelOverride ?? params.modelId,
 		authProfileId: params.authProfileId,
 		authProfileIdSource: params.authProfileIdSource,
 		thinkLevel: params.thinkLevel,
 		reasoningLevel: params.reasoningLevel,
 		timeoutMs: params.timeoutMs,
 		abortSignal: params.abortSignal,
+		lane: params.lane,
+		toolResultFormat: params.toolResultFormat,
+		verboseLevel: params.verboseLevel,
+		ownerNumbers: params.ownerNumbers,
+		enforceFinalTag: params.enforceFinalTag,
+		execOverrides: params.execOverrides,
+		bashElevated: params.bashElevated,
+		suppressToolErrorWarnings: params.suppressToolErrorWarnings,
+		streamParams: params.streamParams,
+		blockReplyBreak: params.blockReplyBreak,
+		blockReplyChunking: params.blockReplyChunking,
+		requireExplicitMessageTarget: params.requireExplicitMessageTarget,
+		disableMessageTool: params.disableMessageTool,
+		symipulseMs: params.symipulseMs,
 		messageChannel: ch?.messageChannel,
 		messageProvider: ch?.messageProvider,
 		agentAccountId: ch?.agentAccountId,
@@ -35876,26 +35997,92 @@ async function runAgentTurn(params) {
 		onPartialReply: cb?.onDelta ? (payload) => {
 			if (payload.text) cb.onDelta(payload.text);
 		} : void 0,
+		onAssistantMessageStart: cb?.onTypingStart ? () => {
+			cb.onTypingStart();
+			cb?.onLifecycle?.("streaming");
+		} : cb?.onLifecycle ? () => {
+			cb.onLifecycle("streaming");
+		} : void 0,
 		onToolResult: cb?.onToolResult ? (payload) => {
 			if (payload.text) cb.onToolResult("tool", payload.text);
 		} : void 0,
 		onReasoningStream: cb?.onThinking ? (payload) => {
 			if (payload.text) cb.onThinking(payload.text);
 		} : void 0,
-		onAgentEvent: cb?.onAgentEvent
+		onBlockReply: cb?.onBlockReply ? (payload) => {
+			cb.onBlockReply({
+				...payload,
+				isFinal: false
+			});
+		} : void 0,
+		onBlockReplyFlush: cb?.onBlockReplyFlush,
+		onAgentEvent: (evt) => {
+			cb?.onAgentEvent?.(evt);
+			const stream = evt.stream;
+			const data = evt.data;
+			const phase = typeof data?.phase === "string" ? data.phase : "";
+			if (stream === "lifecycle") {
+				if (phase === "start") {
+					cb?.onLifecycle?.("start");
+					cb?.onTypingStart?.();
+				} else if (phase === "end") cb?.onTypingStop?.();
+				else if (phase === "error") {
+					cb?.onLifecycle?.("error");
+					cb?.onTypingStop?.();
+					if (cb?.onError && typeof data?.error === "string") cb.onError(new Error(data.error));
+				}
+			}
+			if (stream === "tool") {
+				const toolName = typeof data?.name === "string" ? data.name : "";
+				if (phase === "start" && toolName) {
+					toolsUsed.push(toolName);
+					cb?.onToolStart?.(toolName, data?.args ?? {});
+					cb?.onTypingStart?.();
+				}
+			}
+			if (stream === "compaction" && phase === "end") cb?.onCompaction?.({
+				tokensBefore: typeof data?.tokensBefore === "number" ? data.tokensBefore : 0,
+				tokensAfter: typeof data?.tokensAfter === "number" ? data.tokensAfter : 0
+			});
+		}
 	});
+	let result;
+	let fallbackProvider;
+	let fallbackModel;
+	const TRANSIENT_RETRY_DELAY_MS = 2500;
+	const maxAttempts = params.retryOnTransientError ? 2 : 1;
+	for (let attempt = 0; attempt < maxAttempts; attempt++) try {
+		if (params.fallbackModels?.length) {
+			const fallbackResult = await runWithModelFallback({
+				cfg: params.config,
+				provider: params.provider ?? "",
+				model: params.modelId ?? "",
+				agentDir,
+				fallbacksOverride: params.fallbackModels,
+				run: (provider, model) => runEmbeddedPiAgent(buildInternalParams(provider, model)),
+				onError: async (fallbackAttempt) => {
+					const fromModel = `${fallbackAttempt.provider}/${fallbackAttempt.model}`;
+					cb?.onFallback?.(fromModel, "(next)", String(fallbackAttempt.error));
+				}
+			});
+			result = fallbackResult.result;
+			fallbackProvider = fallbackResult.provider;
+			fallbackModel = fallbackResult.model;
+		} else result = await runEmbeddedPiAgent(buildInternalParams());
+		break;
+	} catch (err) {
+		const errMsg = err instanceof Error ? err.message : String(err);
+		if (params.retryOnTransientError && attempt < maxAttempts - 1 && isTransientHttpError(errMsg)) {
+			await new Promise((resolve) => setTimeout(resolve, TRANSIENT_RETRY_DELAY_MS));
+			continue;
+		}
+		throw err;
+	}
+	result = result;
 	const responseText = (result.payloads ?? []).filter((p) => p.text && !p.isError).map((p) => p.text).join("\n").trim();
-	const resolvedProvider = result.meta.agentMeta?.provider ?? params.provider ?? "";
-	const resolvedModel = result.meta.agentMeta?.model ?? params.modelId ?? "";
-	if (cb?.onFinal) await cb.onFinal(responseText, {
-		provider: resolvedProvider,
-		modelId: resolvedModel,
-		tokenCount: result.meta.agentMeta?.usage?.total ?? 0,
-		durationMs: Date.now() - startTime,
-		toolsUsed: []
-	});
-	if (cb?.onLifecycle) await cb.onLifecycle(result.meta.error ? "error" : "end");
-	return {
+	const resolvedProvider = fallbackProvider ?? result.meta.agentMeta?.provider ?? params.provider ?? "";
+	const resolvedModel = fallbackModel ?? result.meta.agentMeta?.model ?? params.modelId ?? "";
+	const turnResult = {
 		text: responseText,
 		durationMs: Date.now() - startTime,
 		provider: resolvedProvider,
@@ -35904,6 +36091,23 @@ async function runAgentTurn(params) {
 		didSendViaMessagingTool: result.didSendViaMessagingTool ?? false,
 		rawResult: result
 	};
+	if (params.postRunHooks?.length) {
+		for (const hook of params.postRunHooks) if (hook.shouldRun(turnResult)) try {
+			await hook.execute(turnResult, params);
+		} catch (hookErr) {
+			if (cb?.onError && hookErr instanceof Error) cb.onError(hookErr);
+		}
+		turnResult.durationMs = Date.now() - startTime;
+	}
+	if (cb?.onFinal) await cb.onFinal(responseText, {
+		provider: resolvedProvider,
+		modelId: resolvedModel,
+		tokenCount: result.meta.agentMeta?.usage?.total ?? 0,
+		durationMs: turnResult.durationMs,
+		toolsUsed
+	});
+	if (cb?.onLifecycle) await cb.onLifecycle(result.meta.error ? "error" : "end");
+	return turnResult;
 }
 
 //#endregion
@@ -35911,7 +36115,7 @@ async function runAgentTurn(params) {
 function createDefaultDeps() {
 	return {
 		sendMessageWhatsApp: async (...args) => {
-			const { sendMessageWhatsApp } = await import("./web-Dz2oyzw_.js");
+			const { sendMessageWhatsApp } = await import("./web-DaTTL9M0.js");
 			return await sendMessageWhatsApp(...args);
 		},
 		sendMessageTelegram: async (...args) => {
@@ -53349,7 +53553,7 @@ function loadWebLoginQr() {
 	return webLoginQrPromise;
 }
 function loadWebChannel() {
-	webChannelPromise ??= import("./web-Dz2oyzw_.js");
+	webChannelPromise ??= import("./web-DaTTL9M0.js");
 	return webChannelPromise;
 }
 function loadWhatsAppActions() {
@@ -75711,7 +75915,6 @@ function createBlockReplyDeliveryHandler(params) {
 //#endregion
 //#region src/auto-reply/reply/agent-runner-execution.ts
 async function runAgentTurnWithFallback(params) {
-	const TRANSIENT_HTTP_RETRY_DELAY_MS = 2500;
 	let didLogHeartbeatStrip = false;
 	let autoCompactionCompleted = false;
 	const directlySentBlockKeys = /* @__PURE__ */ new Set();
@@ -75732,199 +75935,216 @@ async function runAgentTurnWithFallback(params) {
 	let fallbackModel = params.followupRun.run.model;
 	let fallbackAttempts = [];
 	let didResetAfterCompactionFailure = false;
-	let didRetryTransientHttpError = false;
-	while (true) try {
-		const normalizeStreamingText = (payload) => {
-			let text = payload.text;
-			if (!params.isHeartbeat && text?.includes("SYMIPULSE_OK")) {
-				const stripped = stripHeartbeatToken(text, { mode: "message" });
-				if (stripped.didStrip && !didLogHeartbeatStrip) {
-					didLogHeartbeatStrip = true;
-					logVerbose("Stripped stray SYMIPULSE_OK token from reply");
-				}
-				if (stripped.shouldSkip && (payload.mediaUrls?.length ?? 0) === 0) return { skip: true };
-				text = stripped.text;
-			}
-			if (isSilentReplyText(text, SILENT_REPLY_TOKEN)) return { skip: true };
-			if (!text) {
-				if ((payload.mediaUrls?.length ?? 0) > 0) return {
-					text: void 0,
-					skip: false
-				};
-				return { skip: true };
+	const normalizeStreamingText = (payload) => {
+		let text = payload.text;
+		if (!params.isHeartbeat && text?.includes("SYMIPULSE_OK")) {
+			const stripped = stripHeartbeatToken(text, { mode: "message" });
+			if (stripped.didStrip && !didLogHeartbeatStrip) {
+				didLogHeartbeatStrip = true;
+				logVerbose("Stripped stray SYMIPULSE_OK token from reply");
 			}
-			const sanitized = sanitizeUserFacingText(text, { errorContext: Boolean(payload.isError) });
-			if (!sanitized.trim()) return { skip: true };
-			return {
-				text: sanitized,
+			if (stripped.shouldSkip && (payload.mediaUrls?.length ?? 0) === 0) return { skip: true };
+			text = stripped.text;
+		}
+		if (isSilentReplyText(text, SILENT_REPLY_TOKEN)) return { skip: true };
+		if (!text) {
+			if ((payload.mediaUrls?.length ?? 0) > 0) return {
+				text: void 0,
 				skip: false
 			};
+			return { skip: true };
+		}
+		const sanitized = sanitizeUserFacingText(text, { errorContext: Boolean(payload.isError) });
+		if (!sanitized.trim()) return { skip: true };
+		return {
+			text: sanitized,
+			skip: false
 		};
-		const handlePartialForTyping = async (payload) => {
-			if (isSilentReplyPrefixText(payload.text, SILENT_REPLY_TOKEN)) return;
-			const { text, skip } = normalizeStreamingText(payload);
-			if (skip || !text) return;
+	};
+	const blockReplyPipeline = params.blockReplyPipeline;
+	const onToolResult = params.opts?.onToolResult;
+	let toolResultChain = Promise.resolve();
+	const serializedOnToolResult = onToolResult ? (name, resultText) => {
+		toolResultChain = toolResultChain.then(async () => {
+			const { text, skip } = normalizeStreamingText({ text: resultText });
+			if (skip) return;
 			await params.typingSignals.signalTextDelta(text);
-			return text;
-		};
-		const blockReplyPipeline = params.blockReplyPipeline;
-		const onToolResult = params.opts?.onToolResult;
-		const fallbackResult = await runWithModelFallback({
-			...resolveModelFallbackOptions(params.followupRun.run),
-			run: (provider, model) => {
-				params.opts?.onModelSelected?.({
-					provider,
-					model,
-					thinkLevel: params.followupRun.run.thinkLevel
-				});
-				if (isCliProvider(provider, params.followupRun.run.config)) {
-					const startedAt = Date.now();
-					notifyAgentRunStart();
-					emitAgentEvent({
-						runId,
-						stream: "lifecycle",
-						data: {
-							phase: "start",
-							startedAt
-						}
-					});
-					const cliSessionId = getCliSessionId(params.getActiveSessionEntry(), provider);
-					return (async () => {
-						let lifecycleTerminalEmitted = false;
-						try {
-							const result = await runCliAgent({
-								sessionId: params.followupRun.run.sessionId,
-								sessionKey: params.sessionKey,
-								agentId: params.followupRun.run.agentId,
-								sessionFile: params.followupRun.run.sessionFile,
-								workspaceDir: params.followupRun.run.workspaceDir,
-								config: params.followupRun.run.config,
-								prompt: params.commandBody,
-								provider,
-								model,
-								thinkLevel: params.followupRun.run.thinkLevel,
-								timeoutMs: params.followupRun.run.timeoutMs,
-								runId,
-								extraSystemPrompt: params.followupRun.run.extraSystemPrompt,
-								ownerNumbers: params.followupRun.run.ownerNumbers,
-								cliSessionId,
-								images: params.opts?.images
-							});
-							const cliText = result.payloads?.[0]?.text?.trim();
-							if (cliText) emitAgentEvent({
-								runId,
-								stream: "assistant",
-								data: { text: cliText }
-							});
-							emitAgentEvent({
-								runId,
-								stream: "lifecycle",
-								data: {
-									phase: "end",
-									startedAt,
-									endedAt: Date.now()
-								}
-							});
-							lifecycleTerminalEmitted = true;
-							return result;
-						} catch (err) {
-							emitAgentEvent({
-								runId,
-								stream: "lifecycle",
-								data: {
-									phase: "error",
-									startedAt,
-									endedAt: Date.now(),
-									error: String(err)
-								}
-							});
-							lifecycleTerminalEmitted = true;
-							throw err;
-						} finally {
-							if (!lifecycleTerminalEmitted) emitAgentEvent({
-								runId,
-								stream: "lifecycle",
-								data: {
-									phase: "error",
-									startedAt,
-									endedAt: Date.now(),
-									error: "CLI run completed without lifecycle terminal event"
-								}
-							});
-						}
-					})();
+			await onToolResult({
+				text,
+				mediaUrls: void 0
+			});
+		}).catch((err) => {
+			logVerbose(`tool result delivery failed: ${String(err)}`);
+		});
+		const task = toolResultChain.finally(() => {
+			params.pendingToolTasks.delete(task);
+		});
+		params.pendingToolTasks.add(task);
+	} : void 0;
+	while (true) try {
+		const run = params.followupRun.run;
+		const resolvedProvider = run.provider;
+		const resolvedModel = run.model;
+		if (isCliProvider(resolvedProvider, run.config)) {
+			const startedAt = Date.now();
+			notifyAgentRunStart();
+			emitAgentEvent({
+				runId,
+				stream: "lifecycle",
+				data: {
+					phase: "start",
+					startedAt
 				}
-				const { authProfile, embeddedContext, senderContext } = buildEmbeddedRunContexts({
-					run: params.followupRun.run,
-					sessionCtx: params.sessionCtx,
-					hasRepliedRef: params.opts?.hasRepliedRef,
-					provider
+			});
+			const cliSessionId = getCliSessionId(params.getActiveSessionEntry(), resolvedProvider);
+			let lifecycleTerminalEmitted = false;
+			try {
+				const cliResult = await runCliAgent({
+					sessionId: run.sessionId,
+					sessionKey: params.sessionKey,
+					agentId: run.agentId,
+					sessionFile: run.sessionFile,
+					workspaceDir: run.workspaceDir,
+					config: run.config,
+					prompt: params.commandBody,
+					provider: resolvedProvider,
+					model: resolvedModel,
+					thinkLevel: run.thinkLevel,
+					timeoutMs: run.timeoutMs,
+					runId,
+					extraSystemPrompt: run.extraSystemPrompt,
+					ownerNumbers: run.ownerNumbers,
+					cliSessionId,
+					images: params.opts?.images
 				});
-				const runBaseParams = buildEmbeddedRunBaseParams({
-					run: params.followupRun.run,
-					provider,
-					model,
+				const cliText = cliResult.payloads?.[0]?.text?.trim();
+				if (cliText) emitAgentEvent({
 					runId,
-					authProfile
+					stream: "assistant",
+					data: { text: cliText }
 				});
-				return runEmbeddedPiAgent({
-					...embeddedContext,
-					groupId: resolveGroupSessionKey(params.sessionCtx)?.id,
-					groupChannel: params.sessionCtx.GroupChannel?.trim() ?? params.sessionCtx.GroupSubject?.trim(),
-					groupSpace: params.sessionCtx.GroupSpace?.trim() ?? void 0,
-					...senderContext,
-					...runBaseParams,
-					prompt: params.commandBody,
-					extraSystemPrompt: params.followupRun.run.extraSystemPrompt,
-					toolResultFormat: (() => {
-						const channel = resolveMessageChannel(params.sessionCtx.Surface, params.sessionCtx.Provider);
-						if (!channel) return "markdown";
-						return isMarkdownCapableMessageChannel(channel) ? "markdown" : "plain";
-					})(),
-					suppressToolErrorWarnings: params.opts?.suppressToolErrorWarnings,
-					images: params.opts?.images,
-					abortSignal: params.opts?.abortSignal,
-					blockReplyBreak: params.resolvedBlockStreamingBreak,
-					blockReplyChunking: params.blockReplyChunking,
-					onPartialReply: async (payload) => {
-						const textForTyping = await handlePartialForTyping(payload);
-						if (!params.opts?.onPartialReply || textForTyping === void 0) return;
-						await params.opts.onPartialReply({
-							text: textForTyping,
-							mediaUrls: payload.mediaUrls
-						});
-					},
-					onAssistantMessageStart: async () => {
-						await params.typingSignals.signalMessageStart();
-						await params.opts?.onAssistantMessageStart?.();
-					},
-					onReasoningStream: params.typingSignals.shouldStartOnReasoning || params.opts?.onReasoningStream ? async (payload) => {
-						await params.typingSignals.signalReasoningDelta();
-						await params.opts?.onReasoningStream?.({
-							text: payload.text,
-							mediaUrls: payload.mediaUrls
-						});
-					} : void 0,
-					onReasoningEnd: params.opts?.onReasoningEnd,
-					onAgentEvent: async (evt) => {
-						const hasLifecyclePhase = evt.stream === "lifecycle" && typeof evt.data.phase === "string";
-						if (evt.stream !== "lifecycle" || hasLifecyclePhase) notifyAgentRunStart();
-						if (evt.stream === "tool") {
-							const phase = typeof evt.data.phase === "string" ? evt.data.phase : "";
-							const name = typeof evt.data.name === "string" ? evt.data.name : void 0;
-							if (phase === "start" || phase === "update") {
-								await params.typingSignals.signalToolStart();
-								await params.opts?.onToolStart?.({
-									name,
-									phase
-								});
-							}
-						}
-						if (evt.stream === "compaction") {
-							if ((typeof evt.data.phase === "string" ? evt.data.phase : "") === "end") autoCompactionCompleted = true;
-						}
-					},
-					onBlockReply: params.opts?.onBlockReply ? createBlockReplyDeliveryHandler({
+				emitAgentEvent({
+					runId,
+					stream: "lifecycle",
+					data: {
+						phase: "end",
+						startedAt,
+						endedAt: Date.now()
+					}
+				});
+				lifecycleTerminalEmitted = true;
+				runResult = cliResult;
+				break;
+			} catch (err) {
+				emitAgentEvent({
+					runId,
+					stream: "lifecycle",
+					data: {
+						phase: "error",
+						startedAt,
+						endedAt: Date.now(),
+						error: String(err)
+					}
+				});
+				lifecycleTerminalEmitted = true;
+				throw err;
+			} finally {
+				if (!lifecycleTerminalEmitted) emitAgentEvent({
+					runId,
+					stream: "lifecycle",
+					data: {
+						phase: "error",
+						startedAt,
+						endedAt: Date.now(),
+						error: "CLI run completed without lifecycle terminal event"
+					}
+				});
+			}
+		}
+		params.opts?.onModelSelected?.({
+			provider: resolvedProvider,
+			model: resolvedModel,
+			thinkLevel: run.thinkLevel
+		});
+		const toolResultFormat = (() => {
+			const channel = resolveMessageChannel(params.sessionCtx.Surface, params.sessionCtx.Provider);
+			return !channel || isMarkdownCapableMessageChannel(channel) ? "markdown" : "plain";
+		})();
+		const turnResult = await runAgentTurn({
+			sessionId: run.sessionId,
+			sessionKey: params.sessionKey ?? run.sessionKey ?? run.sessionId,
+			agentId: run.agentId,
+			workspaceDir: run.workspaceDir,
+			agentDir: run.agentDir,
+			config: run.config,
+			skillsSnapshot: run.skillsSnapshot,
+			prompt: params.commandBody,
+			extraSystemPrompt: run.extraSystemPrompt,
+			images: params.opts?.images,
+			provider: resolvedProvider,
+			modelId: resolvedModel,
+			authProfileId: run.authProfileId,
+			authProfileIdSource: run.authProfileIdSource,
+			thinkLevel: run.thinkLevel,
+			verboseLevel: run.verboseLevel,
+			reasoningLevel: run.reasoningLevel,
+			timeoutMs: run.timeoutMs,
+			runId,
+			abortSignal: params.opts?.abortSignal,
+			toolResultFormat,
+			ownerNumbers: run.ownerNumbers,
+			enforceFinalTag: run.enforceFinalTag,
+			execOverrides: run.execOverrides,
+			bashElevated: run.bashElevated,
+			suppressToolErrorWarnings: params.opts?.suppressToolErrorWarnings,
+			blockReplyBreak: params.resolvedBlockStreamingBreak,
+			blockReplyChunking: params.blockReplyChunking,
+			retryOnTransientError: true,
+			fallbackModels: resolveModelFallbackOptions(run).fallbacksOverride,
+			channel: {
+				messageChannel: resolveMessageChannel(params.sessionCtx.Surface, params.sessionCtx.Provider) ?? void 0,
+				messageProvider: params.sessionCtx.Provider?.trim().toLowerCase() || void 0,
+				agentAccountId: params.sessionCtx.AccountId,
+				messageTo: params.sessionCtx.OriginatingTo ?? params.sessionCtx.To,
+				messageThreadId: params.sessionCtx.MessageThreadId ?? void 0,
+				groupId: resolveGroupSessionKey(params.sessionCtx)?.id,
+				groupChannel: params.sessionCtx.GroupChannel?.trim() ?? params.sessionCtx.GroupSubject?.trim(),
+				groupSpace: params.sessionCtx.GroupSpace?.trim() ?? void 0,
+				senderId: params.sessionCtx.SenderId?.trim() || void 0,
+				senderName: params.sessionCtx.SenderName?.trim() || void 0,
+				senderUsername: params.sessionCtx.SenderUsername?.trim() || void 0,
+				senderE164: params.sessionCtx.SenderE164?.trim() || void 0,
+				senderIsOwner: run.senderIsOwner,
+				currentChannelId: params.sessionCtx.CurrentChannelId,
+				currentThreadTs: params.sessionCtx.CurrentThreadTs,
+				hasRepliedRef: params.opts?.hasRepliedRef
+			},
+			callbacks: {
+				onDelta: async (text) => {
+					if (isSilentReplyPrefixText(text, SILENT_REPLY_TOKEN)) return;
+					const { text: normalized, skip } = normalizeStreamingText({ text });
+					if (skip || !normalized) return;
+					await params.typingSignals.signalTextDelta(normalized);
+					await params.opts?.onPartialReply?.({ text: normalized });
+				},
+				onToolStart: async (name) => {
+					notifyAgentRunStart();
+					await params.typingSignals.signalToolStart();
+					await params.opts?.onToolStart?.({
+						name,
+						phase: "start"
+					});
+				},
+				onToolResult: serializedOnToolResult,
+				onThinking: params.typingSignals.shouldStartOnReasoning || params.opts?.onReasoningStream ? async (text) => {
+					await params.typingSignals.signalReasoningDelta();
+					await params.opts?.onReasoningStream?.({ text });
+				} : void 0,
+				onLifecycle: async (phase) => {
+					if (phase === "start" || phase === "streaming") notifyAgentRunStart();
+				},
+				onBlockReply: params.opts?.onBlockReply ? async (payload) => {
+					await createBlockReplyDeliveryHandler({
 						onBlockReply: params.opts.onBlockReply,
 						currentMessageId: params.sessionCtx.MessageSidFull ?? params.sessionCtx.MessageSid,
 						normalizeStreamingText,
@@ -75933,46 +76153,22 @@ async function runAgentTurnWithFallback(params) {
 						blockStreamingEnabled: params.blockStreamingEnabled,
 						blockReplyPipeline,
 						directlySentBlockKeys
-					}) : void 0,
-					onBlockReplyFlush: params.blockStreamingEnabled && blockReplyPipeline ? async () => {
-						await blockReplyPipeline.flush({ force: true });
-					} : void 0,
-					shouldEmitToolResult: params.shouldEmitToolResult,
-					shouldEmitToolOutput: params.shouldEmitToolOutput,
-					onToolResult: onToolResult ? (() => {
-						let toolResultChain = Promise.resolve();
-						return (payload) => {
-							toolResultChain = toolResultChain.then(async () => {
-								const { text, skip } = normalizeStreamingText(payload);
-								if (skip) return;
-								await params.typingSignals.signalTextDelta(text);
-								await onToolResult({
-									text,
-									mediaUrls: payload.mediaUrls
-								});
-							}).catch((err) => {
-								logVerbose(`tool result delivery failed: ${String(err)}`);
-							});
-							const task = toolResultChain.finally(() => {
-								params.pendingToolTasks.delete(task);
-							});
-							params.pendingToolTasks.add(task);
-						};
-					})() : void 0
-				});
+					})(payload);
+				} : void 0,
+				onBlockReplyFlush: params.blockStreamingEnabled && blockReplyPipeline ? async () => {
+					await blockReplyPipeline.flush({ force: true });
+				} : void 0,
+				onCompaction: () => {
+					autoCompactionCompleted = true;
+				},
+				onAgentEvent: (evt) => {
+					if (evt.stream !== "lifecycle") notifyAgentRunStart();
+				}
 			}
 		});
-		runResult = fallbackResult.result;
-		fallbackProvider = fallbackResult.provider;
-		fallbackModel = fallbackResult.model;
-		fallbackAttempts = Array.isArray(fallbackResult.attempts) ? fallbackResult.attempts.map((attempt) => ({
-			provider: String(attempt.provider ?? ""),
-			model: String(attempt.model ?? ""),
-			error: String(attempt.error ?? ""),
-			reason: attempt.reason ? String(attempt.reason) : void 0,
-			status: typeof attempt.status === "number" ? attempt.status : void 0,
-			code: attempt.code ? String(attempt.code) : void 0
-		})) : [];
+		runResult = turnResult.rawResult;
+		fallbackProvider = turnResult.provider;
+		fallbackModel = turnResult.modelId;
 		const embeddedError = runResult.meta?.error;
 		if (embeddedError && isContextOverflowError(embeddedError.message) && !didResetAfterCompactionFailure && await params.resetSessionAfterCompactionFailure(embeddedError.message)) {
 			didResetAfterCompactionFailure = true;
@@ -76031,14 +76227,6 @@ async function runAgentTurnWithFallback(params) {
 				payload: { text: "⚠️ Session history was corrupted. I've reset the conversation - please try again!" }
 			};
 		}
-		if (isTransientHttp && !didRetryTransientHttpError) {
-			didRetryTransientHttpError = true;
-			defaultRuntime.error(`Transient HTTP provider error before reply (${message}). Retrying once in ${TRANSIENT_HTTP_RETRY_DELAY_MS}ms.`);
-			await new Promise((resolve) => {
-				setTimeout(resolve, TRANSIENT_HTTP_RETRY_DELAY_MS);
-			});
-			continue;
-		}
 		defaultRuntime.error(`Embedded agent failed before reply: ${message}`);
 		const trimmedMessage = (isTransientHttp ? sanitizeUserFacingText(message, { errorContext: true }) : message).replace(/\.\s*$/, "");
 		return {
@@ -76211,7 +76399,7 @@ async function runMemoryFlushIfNeeded(params) {
 	try {
 		await runWithModelFallback({
 			...resolveModelFallbackOptions(params.followupRun.run),
-			run: (provider, model) => {
+			run: async (provider, model) => {
 				const { authProfile, embeddedContext, senderContext } = buildEmbeddedRunContexts({
 					run: params.followupRun.run,
 					sessionCtx: params.sessionCtx,
@@ -76225,21 +76413,46 @@ async function runMemoryFlushIfNeeded(params) {
 					runId: flushRunId,
 					authProfile
 				});
-				return runEmbeddedPiAgent({
-					...embeddedContext,
-					...senderContext,
-					...runBaseParams,
+				return (await runAgentTurn({
+					sessionId: embeddedContext.sessionId,
+					sessionKey: embeddedContext.sessionKey ?? embeddedContext.sessionId ?? "",
+					workspaceDir: runBaseParams.workspaceDir,
+					agentDir: runBaseParams.agentDir,
+					config: runBaseParams.config ?? params.cfg,
+					skillsSnapshot: runBaseParams.skillsSnapshot,
 					prompt: resolveMemoryFlushPromptForRun({
 						prompt: memoryFlushSettings.prompt,
 						cfg: params.cfg
 					}),
 					extraSystemPrompt: flushSystemPrompt,
-					onAgentEvent: (evt) => {
-						if (evt.stream === "compaction") {
-							if ((typeof evt.data.phase === "string" ? evt.data.phase : "") === "end") memoryCompactionCompleted = true;
-						}
-					}
-				});
+					provider,
+					modelId: model,
+					authProfileId: runBaseParams.authProfileId,
+					authProfileIdSource: runBaseParams.authProfileIdSource,
+					thinkLevel: runBaseParams.thinkLevel,
+					verboseLevel: runBaseParams.verboseLevel,
+					reasoningLevel: runBaseParams.reasoningLevel,
+					timeoutMs: runBaseParams.timeoutMs,
+					runId: runBaseParams.runId,
+					ownerNumbers: runBaseParams.ownerNumbers,
+					enforceFinalTag: runBaseParams.enforceFinalTag,
+					execOverrides: runBaseParams.execOverrides,
+					bashElevated: runBaseParams.bashElevated,
+					channel: {
+						messageProvider: embeddedContext.messageProvider,
+						agentAccountId: embeddedContext.agentAccountId,
+						messageTo: embeddedContext.messageTo,
+						messageThreadId: embeddedContext.messageThreadId,
+						senderId: senderContext.senderId,
+						senderName: senderContext.senderName,
+						senderUsername: senderContext.senderUsername,
+						senderE164: senderContext.senderE164,
+						senderIsOwner: runBaseParams.senderIsOwner
+					},
+					callbacks: { onCompaction: () => {
+						memoryCompactionCompleted = true;
+					} }
+				})).rawResult;
 			}
 		});
 		let memoryFlushCompactionCount = activeSessionEntry?.compactionCount ?? (params.sessionKey ? activeSessionStore?.[params.sessionKey]?.compactionCount : 0) ?? 0;
@@ -76554,81 +76767,73 @@ function createFollowupRunner(params) {
 			let fallbackProvider = queued.run.provider;
 			let fallbackModel = queued.run.model;
 			try {
-				const fallbackResult = await runWithModelFallback({
-					cfg: queued.run.config,
-					provider: queued.run.provider,
-					model: queued.run.model,
+				runResult = await runAgentTurn({
+					sessionId: queued.run.sessionId,
+					sessionKey: queued.run.sessionKey ?? queued.run.sessionId,
+					workspaceDir: queued.run.workspaceDir,
 					agentDir: queued.run.agentDir,
-					fallbacksOverride: resolveAgentModelFallbacksOverride(queued.run.config, resolveAgentIdFromSessionKey(queued.run.sessionKey)),
-					run: (provider, model) => {
-						const authProfile = resolveRunAuthProfile(queued.run, provider);
-						return runEmbeddedPiAgent({
-							sessionId: queued.run.sessionId,
-							sessionKey: queued.run.sessionKey,
-							agentId: queued.run.agentId,
-							messageProvider: queued.run.messageProvider,
-							agentAccountId: queued.run.agentAccountId,
-							messageTo: queued.originatingTo,
-							messageThreadId: queued.originatingThreadId,
-							groupId: queued.run.groupId,
-							groupChannel: queued.run.groupChannel,
-							groupSpace: queued.run.groupSpace,
-							senderId: queued.run.senderId,
-							senderName: queued.run.senderName,
-							senderUsername: queued.run.senderUsername,
-							senderE164: queued.run.senderE164,
-							senderIsOwner: queued.run.senderIsOwner,
-							sessionFile: queued.run.sessionFile,
-							workspaceDir: queued.run.workspaceDir,
-							config: queued.run.config,
-							skillsSnapshot: queued.run.skillsSnapshot,
-							prompt: queued.prompt,
-							extraSystemPrompt: queued.run.extraSystemPrompt,
-							ownerNumbers: queued.run.ownerNumbers,
-							enforceFinalTag: queued.run.enforceFinalTag,
-							provider,
-							model,
-							...authProfile,
-							thinkLevel: queued.run.thinkLevel,
-							verboseLevel: queued.run.verboseLevel,
-							reasoningLevel: queued.run.reasoningLevel,
-							suppressToolErrorWarnings: opts?.suppressToolErrorWarnings,
-							execOverrides: queued.run.execOverrides,
-							bashElevated: queued.run.bashElevated,
-							timeoutMs: queued.run.timeoutMs,
-							runId,
-							blockReplyBreak: queued.run.blockReplyBreak,
-							onAgentEvent: (evt) => {
-								if (evt.stream !== "compaction") return;
-								if ((typeof evt.data.phase === "string" ? evt.data.phase : "") === "end") autoCompactionCompleted = true;
-							}
-						});
-					}
+					config: queued.run.config,
+					skillsSnapshot: queued.run.skillsSnapshot,
+					prompt: queued.prompt,
+					extraSystemPrompt: queued.run.extraSystemPrompt,
+					provider: queued.run.provider,
+					modelId: queued.run.model,
+					authProfileId: queued.run.authProfileId,
+					authProfileIdSource: queued.run.authProfileIdSource,
+					thinkLevel: queued.run.thinkLevel,
+					verboseLevel: queued.run.verboseLevel,
+					reasoningLevel: queued.run.reasoningLevel,
+					timeoutMs: queued.run.timeoutMs,
+					runId,
+					ownerNumbers: queued.run.ownerNumbers,
+					enforceFinalTag: queued.run.enforceFinalTag,
+					execOverrides: queued.run.execOverrides,
+					bashElevated: queued.run.bashElevated,
+					suppressToolErrorWarnings: opts?.suppressToolErrorWarnings,
+					blockReplyBreak: queued.run.blockReplyBreak,
+					fallbackModels: resolveAgentModelFallbacksOverride(queued.run.config, resolveAgentIdFromSessionKey(queued.run.sessionKey)),
+					channel: {
+						messageProvider: queued.run.messageProvider,
+						agentAccountId: queued.run.agentAccountId,
+						messageTo: queued.originatingTo,
+						messageThreadId: queued.originatingThreadId,
+						groupId: queued.run.groupId,
+						groupChannel: queued.run.groupChannel,
+						groupSpace: queued.run.groupSpace,
+						senderId: queued.run.senderId,
+						senderName: queued.run.senderName,
+						senderUsername: queued.run.senderUsername,
+						senderE164: queued.run.senderE164,
+						senderIsOwner: queued.run.senderIsOwner
+					},
+					callbacks: { onCompaction: () => {
+						autoCompactionCompleted = true;
+					} }
 				});
-				runResult = fallbackResult.result;
-				fallbackProvider = fallbackResult.provider;
-				fallbackModel = fallbackResult.model;
+				fallbackProvider = runResult.provider;
+				fallbackModel = runResult.modelId;
 			} catch (err) {
 				const message = err instanceof Error ? err.message : String(err);
 				defaultRuntime.error?.(`Followup agent failed before reply: ${message}`);
 				return;
 			}
-			const usage = runResult.meta?.agentMeta?.usage;
-			const promptTokens = runResult.meta?.agentMeta?.promptTokens;
-			const modelUsed = runResult.meta?.agentMeta?.model ?? fallbackModel ?? defaultModel;
+			const rawResult = runResult.rawResult;
+			const usage = rawResult.meta?.agentMeta?.usage;
+			const promptTokens = rawResult.meta?.agentMeta?.promptTokens;
+			const modelUsed = rawResult.meta?.agentMeta?.model ?? fallbackModel ?? defaultModel;
 			const contextTokensUsed = agentCfgContextTokens ?? lookupContextTokens(modelUsed) ?? sessionEntry?.contextTokens ?? DEFAULT_CONTEXT_TOKENS;
 			if (storePath && sessionKey) await persistRunSessionUsage({
 				storePath,
 				sessionKey,
 				usage,
-				lastCallUsage: runResult.meta?.agentMeta?.lastCallUsage,
+				lastCallUsage: rawResult.meta?.agentMeta?.lastCallUsage,
 				promptTokens,
 				modelUsed,
 				providerUsed: fallbackProvider,
 				contextTokensUsed,
 				logLabel: "followup"
 			});
-			const payloadArray = runResult.payloads ?? [];
+			const payloadArray = rawResult.payloads ?? [];
 			if (payloadArray.length === 0) return;
 			const sanitizedPayloads = payloadArray.flatMap((payload) => {
 				const text = payload.text;
@@ -76649,13 +76854,13 @@ function createFollowupRunner(params) {
 						replyToMode: resolveReplyToMode(queued.run.config, replyToChannel, queued.originatingAccountId, queued.originatingChatType),
 						replyToChannel
 					}),
-					sentTexts: runResult.messagingToolSentTexts ?? []
+					sentTexts: rawResult.messagingToolSentTexts ?? []
 				}),
-				sentMediaUrls: runResult.messagingToolSentMediaUrls ?? []
+				sentMediaUrls: rawResult.messagingToolSentMediaUrls ?? []
 			});
 			const finalPayloads = shouldSuppressMessagingToolReplies({
 				messageProvider: queued.run.messageProvider,
-				messagingToolSentTargets: runResult.messagingToolSentTargets,
+				messagingToolSentTargets: rawResult.messagingToolSentTargets,
 				originatingTo: queued.originatingTo,
 				accountId: queued.run.agentAccountId
 			}) ? [] : mediaFilteredPayloads;
@@ -76666,7 +76871,7 @@ function createFollowupRunner(params) {
 					sessionStore,
 					sessionKey,
 					storePath,
-					lastCallUsage: runResult.meta?.agentMeta?.lastCallUsage,
+					lastCallUsage: rawResult.meta?.agentMeta?.lastCallUsage,
 					contextTokensUsed
 				});
 				if (queued.run.verboseLevel && queued.run.verboseLevel !== "off") {