@openclaw/ai 2026.9.1 → 2026.9.3

package/dist/{api-registry-Cs6HGNqY.d.mts → api-registry-CB1-1oQ2.d.mts}

@@ -1,5 +1,5 @@
-import "./index-AfaxKT8w.mjs";
-import { D as Model, J as StreamOptions, W as SimpleStreamOptions, d as Context, n as Api, q as StreamFunction, s as AssistantMessageEventStreamContract } from "./types-DbrhszyQ.mjs";
+import "./index-CQ6LTHw8.mjs";
+import { D as Model, J as StreamOptions, W as SimpleStreamOptions, d as Context, n as Api, q as StreamFunction, s as AssistantMessageEventStreamContract } from "./types-Dy1q0CSu.mjs";
 //#region packages/ai/src/api-registry.d.ts
 /** Runtime stream adapter signature stored in the API provider registry. */
 type ApiStreamFunction = (model: Model, context: Context, options?: StreamOptions) => AssistantMessageEventStreamContract;

package/dist/assistant-output-iqnlJCV2.mjs

@@ -0,0 +1,16 @@
+import { i as createEmptyTransportUsage } from "./transport-stream-shared-Cu3ZPhNW.mjs";
+//#region packages/ai/src/transports/assistant-output.ts
+function createAssistantOutput(model, api = model.api) {
+	return {
+		role: "assistant",
+		content: [],
+		api,
+		provider: model.provider,
+		model: model.id,
+		usage: createEmptyTransportUsage(),
+		stopReason: "stop",
+		timestamp: Date.now()
+	};
+}
+//#endregion
+export { createAssistantOutput as t };

package/dist/assistant-text-phase-C20rxWwP.mjs

@@ -0,0 +1,55 @@
+import { randomUUID } from "node:crypto";
+//#region packages/ai/src/utils/assistant-text-phase.ts
+const EMPTY_ASSISTANT_TEXT_BLOCK_SET = /* @__PURE__ */ new Set();
+function isAssistantTextPhaseBlock(block) {
+	if (!block || typeof block !== "object") return false;
+	const record = block;
+	return record.type === "text" && typeof record.text === "string";
+}
+function encodeAssistantTextSignatureV1(id, phase) {
+	return JSON.stringify({
+		v: 1,
+		id,
+		...phase ? { phase } : {}
+	});
+}
+function tagUnphasedText(content, phase, idPrefix) {
+	const textBlocks = content.filter(isAssistantTextPhaseBlock);
+	let phaseIndex = textBlocks.filter((block) => block.textSignature !== void 0).length;
+	const tagged = /* @__PURE__ */ new Map();
+	for (const block of textBlocks) {
+		if (block.text.trim().length === 0 || block.textSignature !== void 0) continue;
+		const signature = encodeAssistantTextSignatureV1(`${idPrefix}-${phaseIndex}-${randomUUID().replaceAll("-", "").slice(0, 24)}`, phase);
+		block.textSignature = signature;
+		tagged.set(block, signature);
+		phaseIndex += 1;
+	}
+	return tagged;
+}
+/** Tags unphased narration before a tool-call event becomes consumer-visible. */
+function tagPendingCommentaryText(content) {
+	return tagUnphasedText(content, "commentary", "commentary");
+}
+/** Records the confirmed final-answer boundary after reasoning resumes. */
+function tagInterruptedTextPhases(content, interruptedText, preservedVisibleText = EMPTY_ASSISTANT_TEXT_BLOCK_SET) {
+	const interruptedTextIndex = content.indexOf(interruptedText);
+	if (interruptedTextIndex === -1) return;
+	const finalAnswerIndex = content.findIndex((block, index) => index > interruptedTextIndex && isAssistantTextPhaseBlock(block) && block.text.trim().length > 0);
+	if (finalAnswerIndex === -1) return;
+	tagUnphasedText(content.slice(0, finalAnswerIndex).filter((block) => !preservedVisibleText.has(block)), "commentary", "commentary");
+	tagUnphasedText(content.filter((block, index) => index >= finalAnswerIndex || preservedVisibleText.has(block)), "final_answer", "final-answer");
+}
+/** Prevents unresolved completion text from becoming a fallback answer after stream failure. */
+function tagUnresolvedTextAsCommentary(message) {
+	if (message.openclawDelivery?.textPhaseRequiresTerminal) tagUnphasedText(message.content, "commentary", "commentary");
+}
+/** Rolls back only the exact provisional signatures created by this transport turn. */
+function clearPendingCommentaryText(tags) {
+	for (const [block, signature] of tags) if (block.textSignature === signature) delete block.textSignature;
+	tags.clear();
+}
+function rememberPendingCommentaryTags(target, tagged) {
+	for (const [block, signature] of tagged) target.set(block, signature);
+}
+//#endregion
+export { tagUnresolvedTextAsCommentary as a, tagPendingCommentaryText as i, rememberPendingCommentaryTags as n, tagInterruptedTextPhases as r, clearPendingCommentaryText as t };

package/dist/{azure-openai-responses-CN4Fy5zV.mjs → azure-openai-responses-Crpa40QR.mjs}

@@ -1,9 +1,9 @@
-import { t as AssistantMessageEventStream } from "./event-stream-uSMZJ3FA.mjs";
-import { n as getAiTransportHost } from "./host-BIaiBURL.mjs";
-import { n as clampOpenAIPromptCacheKey } from "./openai-prompt-cache-mZTCdRPo.mjs";
-import { n as buildBaseOptions } from "./simple-options-0PLDyJ-d.mjs";
+import { t as AssistantMessageEventStream } from "./event-stream-D8PARQfL.mjs";
+import { n as getAiTransportHost } from "./host-CWuF-sS3.mjs";
+import { n as clampOpenAIPromptCacheKey } from "./openai-prompt-cache-BI0rkM-5.mjs";
+import { n as buildBaseOptions } from "./simple-options-tcKOqnpF.mjs";
 import { n as getEnvApiKey } from "./env-api-keys-bktO00EJ.mjs";
-import { a as resolveResponsesReasoningEffort, i as createResponsesAssistantOutput, o as runResponsesStreamLifecycle, r as convertResponsesMessages, t as applyCommonResponsesParams } from "./openai-responses-shared-DiAdpNAM.mjs";
+import { a as resolveResponsesReasoningEffort, i as createResponsesAssistantOutput, r as convertResponsesMessages, s as runResponsesStreamLifecycle, t as applyCommonResponsesParams } from "./openai-responses-shared-ZyQEzS5i.mjs";
 import { i as resolveAzureDeploymentNameFromMap, t as isOpenAICompatibleAzureResponsesBaseUrl } from "./azure-openai-responses-client-compat-C7K7QfUE.mjs";
 import OpenAI, { AzureOpenAI } from "openai";
 //#region packages/ai/src/providers/azure-openai-responses.ts

package/dist/{base64-CEFBpSkN.mjs → base64-D-su8YVo.mjs}

@@ -8,18 +8,6 @@ function asNonNegativeFiniteNumber(value) {
 	const number = asFiniteNumber(value);
 	return number && number < 0 ? void 0 : number;
 }
-/** Returns a finite number only when it satisfies the supplied inclusive/exclusive bounds. */
-function asFiniteNumberInRange(value, range) {
-	const number = asFiniteNumber(value);
-	if (number === void 0) return;
-	if (range.min !== void 0) {
-		if (range.minExclusive ? number <= range.min : number < range.min) return;
-	}
-	if (range.max !== void 0) {
-		if (range.maxExclusive ? number >= range.max : number > range.max) return;
-	}
-	return number;
-}
 function normalizeNumericString(value) {
 	const trimmed = value.trim();
 	return trimmed ? trimmed : void 0;
@@ -33,15 +21,6 @@ function parseStrictInteger(value) {
 	const parsed = Number(normalized);
 	return Number.isSafeInteger(parsed) ? parsed : void 0;
 }
-/** Parses only finite decimal/scientific string tokens, rejecting partial numbers. */
-function parseStrictFiniteNumber(value) {
-	if (typeof value === "number") return Number.isFinite(value) ? value : void 0;
-	if (typeof value !== "string") return;
-	const normalized = normalizeNumericString(value);
-	if (!normalized || !/^[+-]?(?:(?:\d+\.?\d*)|(?:\.\d+))(?:e[+-]?\d+)?$/i.test(normalized)) return;
-	const parsed = Number(normalized);
-	return Number.isFinite(parsed) ? parsed : void 0;
-}
 /** Conservative upper bound for Node timer delays. */
 const MAX_TIMER_TIMEOUT_MS = 2147e6;
 /** Clamps finite millisecond values into the Node-safe timer range. */
@@ -62,11 +41,6 @@ function parseStrictPositiveInteger(value) {
 	const parsed = parseStrictInteger(value);
 	return parsed !== void 0 && parsed > 0 ? parsed : void 0;
 }
-/** Parses strict non-negative integer values from numbers or strings. */
-function parseStrictNonNegativeInteger(value) {
-	const parsed = parseStrictInteger(value);
-	return parsed !== void 0 && parsed >= 0 ? parsed : void 0;
-}
 //#endregion
 //#region packages/media-core/src/base64.ts
 /** Estimates decoded bytes without allocating a cleaned copy of the base64 payload. */
@@ -140,4 +114,4 @@ function canonicalizeBase64(base64) {
 	return remainder === 0 ? cleaned : cleaned + "=".repeat(4 - remainder);
 }
 //#endregion
-export { asNonNegativeFiniteNumber as a, parseStrictNonNegativeInteger as c, asFiniteNumberInRange as i, parseStrictPositiveInteger as l, estimateBase64DecodedBytes as n, clampTimerTimeoutMs as o, asFiniteNumber as r, parseStrictFiniteNumber as s, canonicalizeBase64 as t, resolveTimerTimeoutMs as u };
+export { clampTimerTimeoutMs as a, asNonNegativeFiniteNumber as i, estimateBase64DecodedBytes as n, parseStrictPositiveInteger as o, asFiniteNumber as r, resolveTimerTimeoutMs as s, canonicalizeBase64 as t };

package/dist/{diagnostics-KhXK-QJI.mjs → diagnostics-dV98PqIy.mjs}

@@ -1,6 +1,13 @@
-import { c as normalizeLowercaseStringOrEmpty } from "./utf16-slice-qz3nsy87.mjs";
-import "./provider-error-B6EGq6gg.mjs";
+import { n as normalizeLowercaseStringOrEmpty } from "./string-coerce-fsri9iCu.mjs";
+import "./provider-error-C6TbKiey.mjs";
 //#region packages/normalization-core/src/error-coercion.ts
+function readProperty(value, key) {
+	try {
+		return value[key];
+	} catch {
+		return;
+	}
+}
 /**
 * Normalizes an unknown thrown value into an Error. Non-Error objects become
 * the `cause` and have their enumerable fields copied so structured details
@@ -15,7 +22,7 @@ function toErrorObject(value, fallbackMessage) {
 }
 function extractErrorCode(err) {
 	if (!err || typeof err !== "object") return;
-	const code = err.code;
+	const code = readProperty(err, "code");
 	if (typeof code === "string") return code;
 	if (typeof code === "number") return String(code);
 }
@@ -25,16 +32,15 @@ function readErrorName(err) {
 	return typeof name === "string" ? name : "";
 }
 function collectErrorGraphCandidates(err, resolveNested) {
-	const queue = [err];
-	const seen = /* @__PURE__ */ new Set();
-	const candidates = [];
-	while (queue.length > 0) {
-		const current = queue.shift();
-		if (current == null || seen.has(current)) continue;
-		seen.add(current);
-		candidates.push(current);
+	if (err == null) return [];
+	const candidates = [err];
+	const seen = (/* @__PURE__ */ new Set()).add(err);
+	for (const current of candidates) {
 		if (!current || typeof current !== "object" || !resolveNested) continue;
-		for (const nested of resolveNested(current)) if (nested != null && !seen.has(nested)) queue.push(nested);
+		for (const nested of resolveNested(current)) if (nested != null && !seen.has(nested)) {
+			seen.add(nested);
+			candidates.push(nested);
+		}
 	}
 	return candidates;
 }
@@ -49,18 +55,20 @@ function extractErrorCodeOrErrno(err) {
 function collectNestedErrorCandidates(err) {
 	return collectErrorGraphCandidates(err, (current) => {
 		const nested = [
-			current.cause,
-			current.reason,
-			current.original,
-			current.error,
-			current.data
+			readProperty(current, "cause"),
+			readProperty(current, "reason"),
+			readProperty(current, "original"),
+			readProperty(current, "error"),
+			readProperty(current, "data")
 		];
-		if (Array.isArray(current.errors)) nested.push(...current.errors);
+		const errors = readProperty(current, "errors");
+		if (Array.isArray(errors)) nested.push(...errors);
 		return nested;
 	});
 }
 //#endregion
 //#region packages/ai/src/utils/retryable-network-errors.ts
+const WEBSOCKET_NON_RETRYABLE_CLOSE_ERROR_CODE = "ERR_WEBSOCKET_NON_RETRYABLE_CLOSE";
 const TRANSIENT_NETWORK_CODES = /* @__PURE__ */ new Set([
 	"ECONNRESET",
 	"ECONNREFUSED",
@@ -83,7 +91,8 @@ const TRANSIENT_NETWORK_CODES = /* @__PURE__ */ new Set([
 	"ERR_HTTP2_INVALID_SESSION",
 	"EPROTO",
 	"ERR_SSL_WRONG_VERSION_NUMBER",
-	"ERR_SSL_PROTOCOL_RETURNED_AN_ERROR"
+	"ERR_SSL_PROTOCOL_RETURNED_AN_ERROR",
+	"ERR_WEBSOCKET_TRANSPORT"
 ]);
 const TRANSIENT_NETWORK_ERROR_NAMES = /* @__PURE__ */ new Set([
 	"AbortError",
@@ -118,7 +127,9 @@ function hasRetryableConnectionErrorCode(message) {
 /** Returns true when any nested error proves a transient network failure. */
 function isTransientNetworkError(err) {
 	if (!err) return false;
-	for (const candidate of collectNestedErrorCandidates(err)) {
+	const candidates = collectNestedErrorCandidates(err);
+	if (candidates.some((candidate) => extractErrorCodeOrErrno(candidate) === "ERR_WEBSOCKET_NON_RETRYABLE_CLOSE")) return false;
+	for (const candidate of candidates) {
 		const code = extractErrorCodeOrErrno(candidate);
 		if (code && TRANSIENT_NETWORK_CODES.has(code)) return true;
 		const name = readErrorName(candidate);
@@ -133,4 +144,68 @@ function isTransientNetworkError(err) {
 	return false;
 }
 //#endregion
-export { isTransientNetworkError as n, toErrorObject as r, hasRetryableConnectionErrorCode as t };
+//#region packages/ai/src/transports/model-transport-debug.ts
+/**
+* Environment-driven debug controls for model transport logging.
+*
+* Model adapters share these helpers so payload, SSE, and transport diagnostics
+* interpret OpenClaw debug environment variables consistently.
+*/
+function isTruthyEnv(value) {
+	const normalized = normalizeLowercaseStringOrEmpty(value);
+	return normalized.length > 0 && normalized !== "0" && normalized !== "false" && normalized !== "off" && normalized !== "no";
+}
+/** Resolves model payload debug verbosity from `OPENCLAW_DEBUG_MODEL_PAYLOAD`. */
+function resolveModelPayloadDebugMode(env = process.env) {
+	const normalized = normalizeLowercaseStringOrEmpty(env.OPENCLAW_DEBUG_MODEL_PAYLOAD);
+	if (normalized === "tools" || normalized === "full-redacted") return normalized;
+	if (normalized === "summary") return "summary";
+	return "off";
+}
+/** Resolves SSE stream debug verbosity from `OPENCLAW_DEBUG_SSE`. */
+function resolveModelSseDebugMode(env = process.env) {
+	const normalized = normalizeLowercaseStringOrEmpty(env.OPENCLAW_DEBUG_SSE);
+	if (normalized === "peek") return "peek";
+	if (normalized === "events" || isTruthyEnv(normalized)) return "events";
+	return "off";
+}
+/** Returns whether any model transport debug channel is enabled. */
+function isModelTransportDebugEnabled(env = process.env) {
+	return isTruthyEnv(env.OPENCLAW_DEBUG_MODEL_TRANSPORT) || resolveModelPayloadDebugMode(env) !== "off" || resolveModelSseDebugMode(env) !== "off" || isTruthyEnv(env.OPENCLAW_DEBUG_CODE_MODE);
+}
+function isModelFetchMetadataMessage(message) {
+	return message.startsWith("[model-fetch]");
+}
+/** Emits model-fetch metadata at info level by default; other diagnostics require debug env. */
+function emitModelTransportDebug(log, message) {
+	if (isModelFetchMetadataMessage(message) || isModelTransportDebugEnabled()) {
+		log.info(message);
+		return;
+	}
+	log.debug(message);
+}
+//#endregion
+//#region packages/ai/src/transports/model-transport-url.ts
+/**
+* Debug formatting helpers for model transport endpoints.
+* Keeps logs useful without exposing credentials, request params, or fragments.
+*/
+/** Return a sanitized URL suitable for logs and diagnostics. */
+function formatModelTransportDebugUrl(rawUrl) {
+	try {
+		const parsed = new URL(rawUrl);
+		parsed.username = "";
+		parsed.password = "";
+		parsed.search = "";
+		parsed.hash = "";
+		return parsed.toString();
+	} catch {
+		return "<invalid-url>";
+	}
+}
+/** Format a configured base URL for debug output, or the implicit default. */
+function formatModelTransportDebugBaseUrl(rawUrl) {
+	return rawUrl ? formatModelTransportDebugUrl(rawUrl) : "default";
+}
+//#endregion
+export { resolveModelSseDebugMode as a, isTransientNetworkError as c, resolveModelPayloadDebugMode as i, extractErrorCodeOrErrno as l, formatModelTransportDebugUrl as n, WEBSOCKET_NON_RETRYABLE_CLOSE_ERROR_CODE as o, emitModelTransportDebug as r, hasRetryableConnectionErrorCode as s, formatModelTransportDebugBaseUrl as t, toErrorObject as u };

package/dist/diagnostics.d.mts

@@ -1,5 +1,6 @@
 import { a as extractDiagnosticError, i as createAssistantMessageDiagnostic, n as DiagnosticErrorInfo, o as formatThrownValue, r as appendAssistantMessageDiagnostic, s as isProviderRefusalAssistantError, t as AssistantMessageDiagnostic } from "./diagnostics-DnPnOui6.mjs";
 import { n as ProviderErrorRedactor, r as configureProviderErrorRedactor } from "./provider-error-CzNw4BWX.mjs";
+import { n as formatModelTransportDebugUrl, r as emitModelTransportDebug, t as formatModelTransportDebugBaseUrl } from "./model-transport-url-DKocrEsb.mjs";
 //#region packages/ai/src/utils/credential-redaction.d.ts
 type DiagnosticMediaField = {
   kind: "context";
@@ -22,8 +23,9 @@ export declare function projectDiagnosticValue(value: unknown, policy?: Diagnost
 }): unknown;
 //#endregion
 //#region packages/ai/src/utils/retryable-network-errors.d.ts
+export declare const WEBSOCKET_NON_RETRYABLE_CLOSE_ERROR_CODE = "ERR_WEBSOCKET_NON_RETRYABLE_CLOSE";
 export declare function hasRetryableConnectionErrorCode(message: string): boolean;
 /** Returns true when any nested error proves a transient network failure. */
 export declare function isTransientNetworkError(err: unknown): boolean;
 //#endregion
-export { AssistantMessageDiagnostic, DiagnosticErrorInfo, type DiagnosticProjectionPolicy, type ProviderErrorRedactor, appendAssistantMessageDiagnostic, configureProviderErrorRedactor, createAssistantMessageDiagnostic, extractDiagnosticError, formatThrownValue, isProviderRefusalAssistantError };
+export { AssistantMessageDiagnostic, DiagnosticErrorInfo, type DiagnosticProjectionPolicy, type ProviderErrorRedactor, appendAssistantMessageDiagnostic, configureProviderErrorRedactor, createAssistantMessageDiagnostic, emitModelTransportDebug, extractDiagnosticError, formatModelTransportDebugBaseUrl, formatModelTransportDebugUrl, formatThrownValue, isProviderRefusalAssistantError };

package/dist/diagnostics.mjs

@@ -1,4 +1,4 @@
 import { a as isProviderRefusalAssistantError, i as formatThrownValue, n as createAssistantMessageDiagnostic, r as extractDiagnosticError, t as appendAssistantMessageDiagnostic } from "./diagnostics-CPeq9F7y.mjs";
-import { r as projectDiagnosticValue, t as configureProviderErrorRedactor } from "./provider-error-B6EGq6gg.mjs";
-import { n as isTransientNetworkError, t as hasRetryableConnectionErrorCode } from "./diagnostics-KhXK-QJI.mjs";
-export { appendAssistantMessageDiagnostic, configureProviderErrorRedactor, createAssistantMessageDiagnostic, extractDiagnosticError, formatThrownValue, hasRetryableConnectionErrorCode, isProviderRefusalAssistantError, isTransientNetworkError, projectDiagnosticValue };
+import { r as projectDiagnosticValue, t as configureProviderErrorRedactor } from "./provider-error-C6TbKiey.mjs";
+import { c as isTransientNetworkError, n as formatModelTransportDebugUrl, o as WEBSOCKET_NON_RETRYABLE_CLOSE_ERROR_CODE, r as emitModelTransportDebug, s as hasRetryableConnectionErrorCode, t as formatModelTransportDebugBaseUrl } from "./diagnostics-dV98PqIy.mjs";
+export { WEBSOCKET_NON_RETRYABLE_CLOSE_ERROR_CODE, appendAssistantMessageDiagnostic, configureProviderErrorRedactor, createAssistantMessageDiagnostic, emitModelTransportDebug, extractDiagnosticError, formatModelTransportDebugBaseUrl, formatModelTransportDebugUrl, formatThrownValue, hasRetryableConnectionErrorCode, isProviderRefusalAssistantError, isTransientNetworkError, projectDiagnosticValue };

package/dist/{event-stream-vK_7r3bj.d.mts → event-stream-C1Z2piyk.d.mts}

@@ -1,11 +1,15 @@
-import { a as AssistantMessage, o as AssistantMessageEvent, s as AssistantMessageEventStreamContract } from "./types-DbrhszyQ.mjs";
+import { Q as ThinkingContent, a as AssistantMessage, o as AssistantMessageEvent, s as AssistantMessageEventStreamContract } from "./types-Dy1q0CSu.mjs";
 //#region packages/llm-core/src/utils/event-stream.d.ts
+/** Returns only an append whose current and previously observed snapshots still match. */
+declare function readAssistantThinkingAppend(block: ThinkingContent, previous: string): string | undefined;
+/** Observe native producer settlement without invoking consumer result decorators. */
+declare function getEventStreamCompletion(stream: object): Promise<unknown> | undefined;
 /** Generic async-iterable event stream with a separately awaited final result. */
 declare class EventStream<T, R = T> implements AsyncIterable<T> {
   private queue;
   private queueHead;
   private waiting;
-  private done;
+  protected done: boolean;
   private resultSettled;
   private finalResultPromise;
   private resolveFinalResult;
@@ -20,9 +24,13 @@ declare class EventStream<T, R = T> implements AsyncIterable<T> {
 }
 /** Assistant-message event stream that resolves on done/error terminal events. */
 declare class AssistantMessageEventStream extends EventStream<AssistantMessageEvent, AssistantMessage> implements AssistantMessageEventStreamContract {
+  private activeThinkingBlocks?;
+  push(event: AssistantMessageEvent): void;
+  end(result?: AssistantMessage): void;
+  private clearThinkingAppends;
   constructor();
 }
 /** Creates an assistant-message stream for provider and plugin adapters. */
 declare function createAssistantMessageEventStream(): AssistantMessageEventStream;
 //#endregion
-export { EventStream as n, createAssistantMessageEventStream as r, AssistantMessageEventStream as t };
+export { readAssistantThinkingAppend as a, getEventStreamCompletion as i, EventStream as n, createAssistantMessageEventStream as r, AssistantMessageEventStream as t };

package/dist/{event-stream-uSMZJ3FA.mjs → event-stream-D8PARQfL.mjs}

@@ -1,4 +1,25 @@
 //#region packages/llm-core/src/utils/event-stream.ts
+const thinkingAppends = /* @__PURE__ */ new WeakMap();
+/** Package-internal mutation fact for native reasoning projection. */
+function appendAssistantThinking(block, delta) {
+	const before = block.thinking;
+	block.thinking += delta;
+	thinkingAppends.set(block, {
+		before,
+		after: block.thinking,
+		delta
+	});
+}
+/** Returns only an append whose current and previously observed snapshots still match. */
+function readAssistantThinkingAppend(block, previous) {
+	const append = thinkingAppends.get(block);
+	return append?.before === previous && append.after === block.thinking ? append.delta : void 0;
+}
+const eventStreamCompletions = /* @__PURE__ */ new WeakMap();
+/** Observe native producer settlement without invoking consumer result decorators. */
+function getEventStreamCompletion(stream) {
+	return eventStreamCompletions.get(stream);
+}
 /** Generic async-iterable event stream with a separately awaited final result. */
 var EventStream = class {
 	constructor(isComplete, extractResult) {
@@ -9,17 +30,11 @@ var EventStream = class {
 		this.resultSettled = false;
 		this.isComplete = isComplete;
 		this.extractResult = extractResult;
-		const resolvers = [];
-		const rejecters = [];
 		this.finalResultPromise = new Promise((resolve, reject) => {
-			resolvers.push(resolve);
-			rejecters.push(reject);
+			this.resolveFinalResult = resolve;
+			this.rejectFinalResult = reject;
 		});
-		const resolveFinalResult = resolvers.at(0);
-		const rejectFinalResult = rejecters.at(0);
-		if (!resolveFinalResult || !rejectFinalResult) throw new Error("event stream result promise did not initialize its resolver");
-		this.resolveFinalResult = resolveFinalResult;
-		this.rejectFinalResult = rejectFinalResult;
+		eventStreamCompletions.set(this, this.finalResultPromise);
 	}
 	push(event) {
 		if (this.done) return;
@@ -57,6 +72,7 @@ var EventStream = class {
 	async *[Symbol.asyncIterator]() {
 		while (true) if (this.queueHead < this.queue.length) {
 			const event = this.queue[this.queueHead];
+			this.queue[this.queueHead] = void 0;
 			this.queueHead += 1;
 			if (this.queueHead >= 1024 && this.queueHead * 2 >= this.queue.length) {
 				this.queue = this.queue.slice(this.queueHead);
@@ -78,6 +94,28 @@ var EventStream = class {
 };
 /** Assistant-message event stream that resolves on done/error terminal events. */
 var AssistantMessageEventStream = class extends EventStream {
+	push(event) {
+		if (event.type === "thinking_delta" || event.type === "thinking_end") {
+			const block = event.partial.content[event.contentIndex];
+			if (block?.type === "thinking") {
+				if (this.done || event.type === "thinking_end") {
+					thinkingAppends.delete(block);
+					this.activeThinkingBlocks?.delete(block);
+				} else if (thinkingAppends.has(block)) (this.activeThinkingBlocks ??= /* @__PURE__ */ new Set()).add(block);
+			}
+		}
+		if (event.type === "done" || event.type === "error") this.clearThinkingAppends(event.type === "done" ? event.message : event.error);
+		super.push(event);
+	}
+	end(result) {
+		this.clearThinkingAppends(result);
+		super.end(result);
+	}
+	clearThinkingAppends(message) {
+		for (const block of message?.content ?? []) if (block.type === "thinking") thinkingAppends.delete(block);
+		for (const block of this.activeThinkingBlocks ?? []) thinkingAppends.delete(block);
+		this.activeThinkingBlocks = void 0;
+	}
 	constructor() {
 		super((event) => event.type === "done" || event.type === "error", (event) => {
 			if (event.type === "done") return event.message;
@@ -91,4 +129,4 @@ function createAssistantMessageEventStream() {
 	return new AssistantMessageEventStream();
 }
 //#endregion
-export { EventStream as n, createAssistantMessageEventStream as r, AssistantMessageEventStream as t };
+export { getEventStreamCompletion as a, createAssistantMessageEventStream as i, EventStream as n, readAssistantThinkingAppend as o, appendAssistantThinking as r, AssistantMessageEventStream as t };

package/dist/event-stream-I_GlBsuZ.d.mts

@@ -0,0 +1 @@
+import "./event-stream-C1Z2piyk.mjs";

package/dist/event-stream.d.mts

@@ -1,3 +1,3 @@
-import { n as EventStream, r as createAssistantMessageEventStream, t as AssistantMessageEventStream } from "./event-stream-vK_7r3bj.mjs";
-import "./event-stream-DeDhbCc5.mjs";
+import { n as EventStream, r as createAssistantMessageEventStream, t as AssistantMessageEventStream } from "./event-stream-C1Z2piyk.mjs";
+import "./event-stream-I_GlBsuZ.mjs";
 export { AssistantMessageEventStream, EventStream, createAssistantMessageEventStream };

package/dist/event-stream.mjs

@@ -1,2 +1,2 @@
-import { n as EventStream, r as createAssistantMessageEventStream, t as AssistantMessageEventStream } from "./event-stream-uSMZJ3FA.mjs";
+import { i as createAssistantMessageEventStream, n as EventStream, t as AssistantMessageEventStream } from "./event-stream-D8PARQfL.mjs";
 export { AssistantMessageEventStream, EventStream, createAssistantMessageEventStream };

package/dist/{github-copilot-headers-NCJtz9i0.mjs → github-copilot-headers-B37TB3rB.mjs}

@@ -1,3 +1,4 @@
+import { t as projectCopilotRequestFacts } from "./github-copilot-request-facts-BTEBMeOv.mjs";
 //#region packages/ai/src/providers/cloudflare.ts
 function isCloudflareProvider(provider) {
 	return provider === "cloudflare-workers-ai" || provider === "cloudflare-ai-gateway";
@@ -14,20 +15,12 @@ function resolveCloudflareBaseUrl(model) {
 }
 //#endregion
 //#region packages/ai/src/providers/github-copilot-headers.ts
-function inferCopilotInitiator(messages) {
-	const last = messages[messages.length - 1];
-	return last && last.role !== "user" ? "agent" : "user";
-}
 function hasCopilotVisionInput(messages) {
-	return messages.some((msg) => {
-		if (msg.role === "user" && Array.isArray(msg.content)) return msg.content.some((c) => c.type === "image");
-		if (msg.role === "toolResult" && Array.isArray(msg.content)) return msg.content.some((c) => c.type === "image");
-		return false;
-	});
+	return projectCopilotRequestFacts(messages, "direct").hasImages;
 }
 function buildCopilotDynamicHeaders(params) {
 	const headers = {
-		"X-Initiator": inferCopilotInitiator(params.messages),
+		"X-Initiator": projectCopilotRequestFacts(params.messages, "direct", params.hasImages).initiator,
 		"Openai-Intent": "conversation-edits"
 	};
 	if (params.hasImages) headers["Copilot-Vision-Request"] = "true";

package/dist/github-copilot-request-facts-BTEBMeOv.mjs

@@ -0,0 +1,16 @@
+//#region packages/ai/src/providers/github-copilot-request-facts.ts
+/** Request facts shared by Copilot transports; identity headers remain plugin-owned. */
+function projectCopilotRequestFacts(messages, contentMode, hasImages) {
+	const last = messages.at(-1);
+	return {
+		initiator: last && (last.role !== "user" || contentMode === "nested" && containsContentType(last.content, "tool_result")) ? "agent" : "user",
+		hasImages: hasImages ?? messages.some((message) => (message.role === "user" || message.role === "toolResult") && Array.isArray(message.content) && message.content.some((item) => containsContentType(item, "image", contentMode)))
+	};
+}
+function containsContentType(value, type, contentMode = "nested") {
+	if (contentMode === "nested" && Array.isArray(value)) return value.some((item) => containsContentType(item, type));
+	if (!value || typeof value !== "object") return false;
+	return "type" in value && value.type === type || contentMode === "nested" && "content" in value && containsContentType(value.content, type);
+}
+//#endregion
+export { projectCopilotRequestFacts as t };

package/dist/{google-CC-nrwXg.mjs → google-BDPriaVe.mjs}

@@ -1,21 +1,24 @@
-import { t as AssistantMessageEventStream } from "./event-stream-uSMZJ3FA.mjs";
-import { n as getAiTransportHost, r as resolveAiTransportHeaderSentinels } from "./host-BIaiBURL.mjs";
-import { n as buildBaseOptions } from "./simple-options-0PLDyJ-d.mjs";
+import { t as AssistantMessageEventStream } from "./event-stream-D8PARQfL.mjs";
+import { n as getAiTransportHost, r as resolveAiTransportHeaderSentinels } from "./host-CWuF-sS3.mjs";
+import { n as buildBaseOptions } from "./simple-options-tcKOqnpF.mjs";
 import { n as getEnvApiKey } from "./env-api-keys-bktO00EJ.mjs";
-import { i as runGoogleGenerateContentLifecycle, n as buildGoogleSimpleThinking, r as createGoogleAssistantOutput, t as buildGoogleGenerateContentParams } from "./google-shared-CjPY0hZM.mjs";
+import { l as mergeTransportHeaders } from "./transport-stream-shared-Cu3ZPhNW.mjs";
+import { t as createAssistantOutput } from "./assistant-output-iqnlJCV2.mjs";
+import { t as resolveOpencodeSessionHeaders } from "./session-affinity-CCH7eYdB.mjs";
+import { n as buildGoogleSimpleThinking, r as runGoogleGenerateContentLifecycle, t as buildGoogleGenerateContentParams } from "./google-shared-BedY23XS.mjs";
 import { GoogleGenAI } from "@google/genai";
 //#region packages/ai/src/providers/google.ts
 let toolCallCounter = 0;
 const streamGoogle = (model, context, options) => {
 	const stream = new AssistantMessageEventStream();
-	const output = createGoogleAssistantOutput(model, "google-generative-ai");
+	const output = createAssistantOutput(model, "google-generative-ai");
 	runGoogleGenerateContentLifecycle({
 		stream,
 		model,
 		output,
 		options,
 		createClient: () => {
-			return createClient(model, options?.apiKey || getEnvApiKey(model.provider) || "", options?.headers);
+			return createClient(model, options?.apiKey || getEnvApiKey(model.provider) || "", resolveOpencodeSessionHeaders(model, options));
 		},
 		buildParams: () => buildParams(model, context, options),
 		nextToolCallId: (name) => `${name}_${Date.now()}_${++toolCallCounter}`
@@ -40,10 +43,7 @@ function createClient(model, apiKey, optionsHeaders) {
 		httpOptions.baseUrl = model.baseUrl;
 		httpOptions.apiVersion = "";
 	}
-	if (model.headers || optionsHeaders) httpOptions.headers = resolveAiTransportHeaderSentinels({
-		...model.headers,
-		...optionsHeaders
-	});
+	if (model.headers || optionsHeaders) httpOptions.headers = resolveAiTransportHeaderSentinels(mergeTransportHeaders(model.headers, optionsHeaders));
 	const resolvedApiKey = apiKey ? getAiTransportHost().resolveSecretSentinel(apiKey) : void 0;
 	return new GoogleGenAI({
 		apiKey: resolvedApiKey,