@gajae-code/ai 0.12.4 → 0.12.6

package/CHANGELOG.md

@@ -2,6 +2,18 @@
 
 ## [Unreleased]
 
+## [0.12.6] - 2026-07-31
+
+## [0.12.5] - 2026-07-30
+### Fixed
+
+- Alibaba Token Plan requests now carry Qwen Code's canonical DashScope request fingerprint on both transports. The built-in `alibaba-token-plan` provider (openai-responses `qwen3.8-max-preview` and openai-completions `glm-5.2`/`deepseek-v4-pro`) now emits the four upstream identity/cache/auth headers (`User-Agent`, `X-DashScope-CacheControl: enable`, `X-DashScope-UserAgent`, `X-DashScope-AuthType: openai`) matching `QwenLM/qwen-code` v0.21.1 (commit `f4cd6e1`) exactly, via a shared helper. DashScope is compatibility-sensitive to this client fingerprint, so a non-identical set can cause request instability and affect first-event latency. Caller headers still win per key (upstream `{...default, ...customHeaders}` precedence); non-Alibaba providers are byte-unchanged (#3557).
+
+### Added
+
+- Reproducible Alibaba Token Plan header-parity A/B latency benchmark (`packages/ai/scripts/alibaba-token-plan-latency-ab.ts`): a fixed-seed interleaved A/B comparison of legacy vs Qwen-identical headers against a deterministic local HTTP server, reporting n/success/error/timeout and TTFT/total latency median/p90/p95/mean/stddev. No live credentials are required; a public-safe blocked-live-data receipt is included (`packages/ai/test/fixtures/alibaba-token-plan-latency-blocked-receipt.md`) (#3557).
+
+
 ## [0.12.4] - 2026-07-30
 
 ### Fixed

package/dist/types/providers/dashscope-token-plan-headers.d.ts

@@ -0,0 +1,57 @@
+/**
+ * DashScope Token Plan canonical request headers.
+ *
+ * Reproduces QwenLM/qwen-code's DashScopeOpenAICompatibleProvider.buildHeaders()
+ * defaultHeaders so the built-in `alibaba-token-plan` provider emits the same
+ * client identity / cache / auth-type fingerprint upstream sends. DashScope is
+ * compatibility-sensitive to this fingerprint; a non-identical set can cause
+ * request instability and affect first-event latency (gajae-code #3557).
+ *
+ * Upstream pin (reproduce EXACTLY here):
+ *   Repository:    QwenLM/qwen-code
+ *   Commit:        f4cd6e1d8bbb1c24e7e5d1a40187d8e28aa7c4fb
+ *   Version:       0.21.1
+ *   Source:        packages/core/src/core/openaiContentGenerator/provider/dashscope.ts
+ *   buildHeaders():
+ *     const userAgent = `QwenCode/${version} (${process.platform}; ${process.arch})`;
+ *     const defaultHeaders = {
+ *       'User-Agent': userAgent,
+ *       'X-DashScope-CacheControl': 'enable',
+ *       'X-DashScope-UserAgent': userAgent,
+ *       'X-DashScope-AuthType': authType,
+ *     };
+ *     return customHeaders ? { ...defaultHeaders, ...customHeaders } : defaultHeaders;
+ *
+ * The Token Plan preset authenticates with AuthType.USE_OPENAI ('openai'), so
+ * X-DashScope-AuthType is the constant 'openai'. Pin the version so an upstream
+ * bump is an explicit parity update rather than silent drift.
+ */
+export declare const QWEN_CODE_UPSTREAM_REPO = "QwenLM/qwen-code";
+export declare const QWEN_CODE_UPSTREAM_COMMIT = "f4cd6e1d8bbb1c24e7e5d1a40187d8e28aa7c4fb";
+export declare const QWEN_CODE_UPSTREAM_VERSION = "0.21.1";
+/**
+ * The Qwen Code CLI version string used in identity headers. Pinned to the
+ * upstream version at {@link QWEN_CODE_UPSTREAM_COMMIT}; change both together
+ * as an explicit parity update.
+ */
+export declare function qwenCodeUserAgent(version?: string): string;
+/**
+ * Canonical DashScope Token Plan headers (upstream defaultHeaders, no caller
+ * overrides applied). Exposed for tests/fixtures so the pinned wire set lives
+ * in exactly one place.
+ */
+export declare function dashscopeTokenPlanDefaultHeaders(version?: string): Readonly<Record<string, string>>;
+/**
+ * Merge canonical DashScope Token Plan identity headers onto a caller's header
+ * map, reproducing upstream buildHeaders() precedence EXACTLY:
+ *   `{ ...defaultHeaders, ...customHeaders }` — caller wins per header.
+ *
+ * This mirrors GJC's existing kimi-code injection order
+ * (`headers = { ...getKimiCommonHeaders(), ...headers }`): canonical identity as
+ * the base, caller-supplied headers overriding individual keys. A caller that
+ * pins `User-Agent` takes that key; the other canonicals still apply.
+ *
+ * A null/undefined `callerHeaders` returns the canonical set alone (upstream
+ * `customHeaders ? {...} : defaultHeaders` shortcut).
+ */
+export declare function mergeDashScopeTokenPlanHeaders(callerHeaders: Record<string, string> | undefined, version?: string): Record<string, string>;

package/dist/types/types.d.ts

@@ -224,19 +224,21 @@ export interface StreamOptions {
     /**
      * Optional callback for inspecting or replacing provider payloads before sending.
      * Return undefined to keep the payload unchanged.
+     * The `scope` parameter carries the per-attempt identity for execution attribution.
      */
-    onPayload?: (payload: unknown, model?: Model<Api>) => unknown | undefined | Promise<unknown | undefined>;
+    onPayload?: (payload: unknown, model?: Model<Api>, scope?: AttemptScopeRef) => unknown | undefined | Promise<unknown | undefined>;
     /**
      * Optional callback for provider response metadata after headers are received.
+     * The `scope` parameter carries the per-attempt identity for execution attribution.
      */
-    onResponse?: (response: ProviderResponseMetadata, model?: Model<Api>) => void | Promise<void>;
+    onResponse?: (response: ProviderResponseMetadata, model?: Model<Api>, scope?: AttemptScopeRef) => void | Promise<void>;
     /**
      * Optional callback for raw Server-Sent Events as they arrive from HTTP streaming providers.
      *
      * Diagnostic only: provider implementations must ignore callback failures and must not
      * let observers alter stream contents.
      */
-    onSseEvent?: (event: RawSseEvent, model?: Model<Api>) => void;
+    onSseEvent?: (event: RawSseEvent, model?: Model<Api>, scope?: AttemptScopeRef) => void;
     /**
      * Optional override for the first streamed event watchdog in milliseconds.
      * Set to 0 to disable the first-event watchdog for this request.
@@ -266,6 +268,22 @@ export interface StreamOptions {
     authCredentialType?: "api_key" | "oauth";
     /** Cursor exec/MCP tool handlers (cursor-agent only). */
     execHandlers?: CursorExecHandlers;
+    /** Per-attempt identity for execution attribution. Threaded into onPayload/onResponse calls. */
+    attemptScope?: AttemptScopeRef;
+}
+/**
+ * Low-level structural carrier for per-attempt identity attribution.
+ *
+ * Defined in `packages/ai` so that {@link SimpleStreamOptions} and provider
+ * hook signatures can carry an attempt identity without a reverse dependency
+ * on `packages/agent`. The concrete `AttemptScope` in `packages/agent` is
+ * structurally assignable to this interface (same `attemptId` + `generation`
+ * + `lineage` fields).
+ */
+export interface AttemptScopeRef {
+    readonly attemptId: string;
+    readonly generation: number;
+    readonly lineage: string;
 }
 export interface SimpleStreamOptions extends StreamOptions {
     reasoning?: Effort;

package/dist/types/utils/provider-response.d.ts

@@ -1,3 +1,6 @@
-import type { Api, Model, ProviderResponseMetadata, StreamOptions } from "../types";
+import type { Api, AttemptScopeRef, Model, ProviderResponseMetadata, StreamOptions } from "../types";
 export declare function normalizeProviderResponse(response: Response, requestId?: string | null, metadata?: Record<string, unknown>): ProviderResponseMetadata;
-export declare function notifyProviderResponse(options: Pick<StreamOptions, "onResponse"> | undefined, response: Response, model?: Model<Api>, requestId?: string | null, metadata?: Record<string, unknown>): Promise<void>;
+export declare function notifyProviderResponse(options: {
+    onResponse?: StreamOptions["onResponse"];
+    attemptScope?: AttemptScopeRef;
+} | undefined, response: Response, model?: Model<Api>, requestId?: string | null, metadata?: Record<string, unknown>): Promise<void>;

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@gajae-code/ai",
-	"version": "0.12.4",
+	"version": "0.12.6",
 	"description": "Unified LLM API with automatic model discovery and provider configuration",
 	"homepage": "https://gajae-code.com",
 	"author": "Yeachan-Heo and Gajae Code Contributors",
@@ -40,7 +40,7 @@
 	"dependencies": {
 		"@anthropic-ai/sdk": "^0.94.0",
 		"@bufbuild/protobuf": "^2.12.0",
-		"@gajae-code/utils": "0.12.4",
+		"@gajae-code/utils": "0.12.6",
 		"openai": "^6.36.0",
 		"partial-json": "^0.1.7",
 		"zod": "4.4.3"

package/src/providers/amazon-bedrock.ts

@@ -228,7 +228,7 @@ export const streamBedrock: StreamFunction<"bedrock-converse-stream"> = (
 				toolConfig,
 				additionalModelRequestFields,
 			};
-			options?.onPayload?.(commandInput);
+			options?.onPayload?.(commandInput, model, options?.attemptScope);
 
 			const host = `bedrock-runtime.${region}.amazonaws.com`;
 			const url = `https://${host}/model/${encodeURIComponent(model.id)}/converse-stream`;

package/src/providers/anthropic.ts

@@ -1348,7 +1348,9 @@ export const streamAnthropic: StreamFunction<"anthropic-messages"> = (
 					dynamicHeaders: copilotDynamicHeaders?.headers,
 					isOAuth: options?.isOAuth,
 					hasTools: !!context.tools?.length,
-					onSseEvent: options?.onSseEvent,
+					onSseEvent: options?.onSseEvent
+						? event => options.onSseEvent!(event, model, options?.attemptScope)
+						: undefined,
 					fetch: options?.fetch,
 					requestMaxRetries: options?.requestMaxRetries,
 					maxRetryDelayMs: options?.maxRetryDelayMs,
@@ -1386,7 +1388,7 @@ export const streamAnthropic: StreamFunction<"anthropic-messages"> = (
 				if (dropFastMode) {
 					dropAnthropicFastMode(nextParams);
 				}
-				const replacementPayload = await options?.onPayload?.(nextParams, model);
+				const replacementPayload = await options?.onPayload?.(nextParams, model, options?.attemptScope);
 				if (replacementPayload !== undefined) {
 					nextParams = replacementPayload as typeof nextParams;
 				}
@@ -1489,7 +1491,7 @@ export const streamAnthropic: StreamFunction<"anthropic-messages"> = (
 					} = await getAnthropicStreamResponse(
 						anthropicRequest,
 						requestSignal,
-						options?.client ? event => options?.onSseEvent?.(event, model) : undefined,
+						options?.client ? event => options?.onSseEvent?.(event, model, options?.attemptScope) : undefined,
 					);
 					await notifyProviderResponse(options, response, model, requestId);
 					let sawEvent = false;

package/src/providers/azure-openai-responses.ts

@@ -126,7 +126,7 @@ export const streamAzureOpenAIResponses: StreamFunction<"azure-openai-responses"
 			const { baseUrl } = resolveAzureConfig(model, options);
 			const params = buildParams(model, context, options, deploymentName, baseUrl);
 			const idleTimeoutMs = options?.streamIdleTimeoutMs ?? getOpenAIStreamIdleTimeoutMs();
-			options?.onPayload?.(params);
+			options?.onPayload?.(params, model, options?.attemptScope);
 			rawRequestDump = {
 				provider: model.provider,
 				api: output.api,
@@ -312,7 +312,9 @@ function createClient(model: Model<"azure-openai-responses">, apiKey: string, op
 		maxRetries: resolveRetryBudget(options?.requestMaxRetries, 5),
 		defaultHeaders: headers,
 		baseURL: baseUrl,
-		fetch: onSseEvent ? wrapFetchForSseDebug(baseFetch, event => onSseEvent(event, model)) : baseFetch,
+		fetch: onSseEvent
+			? wrapFetchForSseDebug(baseFetch, event => onSseEvent(event, model, options?.attemptScope))
+			: baseFetch,
 	});
 }
 

package/src/providers/cursor.ts

@@ -2632,7 +2632,7 @@ function buildGrpcRequest(
 		conversationId: state.conversationId,
 	});
 
-	options?.onPayload?.(runRequest);
+	options?.onPayload?.(runRequest, model, options?.attemptScope);
 
 	// Tools are sent later via requestContext (exec handshake)
 

package/src/providers/dashscope-token-plan-headers.ts

@@ -0,0 +1,84 @@
+/**
+ * DashScope Token Plan canonical request headers.
+ *
+ * Reproduces QwenLM/qwen-code's DashScopeOpenAICompatibleProvider.buildHeaders()
+ * defaultHeaders so the built-in `alibaba-token-plan` provider emits the same
+ * client identity / cache / auth-type fingerprint upstream sends. DashScope is
+ * compatibility-sensitive to this fingerprint; a non-identical set can cause
+ * request instability and affect first-event latency (gajae-code #3557).
+ *
+ * Upstream pin (reproduce EXACTLY here):
+ *   Repository:    QwenLM/qwen-code
+ *   Commit:        f4cd6e1d8bbb1c24e7e5d1a40187d8e28aa7c4fb
+ *   Version:       0.21.1
+ *   Source:        packages/core/src/core/openaiContentGenerator/provider/dashscope.ts
+ *   buildHeaders():
+ *     const userAgent = `QwenCode/${version} (${process.platform}; ${process.arch})`;
+ *     const defaultHeaders = {
+ *       'User-Agent': userAgent,
+ *       'X-DashScope-CacheControl': 'enable',
+ *       'X-DashScope-UserAgent': userAgent,
+ *       'X-DashScope-AuthType': authType,
+ *     };
+ *     return customHeaders ? { ...defaultHeaders, ...customHeaders } : defaultHeaders;
+ *
+ * The Token Plan preset authenticates with AuthType.USE_OPENAI ('openai'), so
+ * X-DashScope-AuthType is the constant 'openai'. Pin the version so an upstream
+ * bump is an explicit parity update rather than silent drift.
+ */
+export const QWEN_CODE_UPSTREAM_REPO = "QwenLM/qwen-code";
+export const QWEN_CODE_UPSTREAM_COMMIT = "f4cd6e1d8bbb1c24e7e5d1a40187d8e28aa7c4fb";
+export const QWEN_CODE_UPSTREAM_VERSION = "0.21.1";
+
+// Upstream Token Plan preset uses AuthType.USE_OPENAI = 'openai'.
+const QWEN_CODE_TOKEN_PLAN_AUTH_TYPE = "openai";
+
+/**
+ * The Qwen Code CLI version string used in identity headers. Pinned to the
+ * upstream version at {@link QWEN_CODE_UPSTREAM_COMMIT}; change both together
+ * as an explicit parity update.
+ */
+export function qwenCodeUserAgent(version: string = QWEN_CODE_UPSTREAM_VERSION): string {
+	// process.platform / process.arch are read verbatim, matching upstream
+	// (e.g. "linux", "darwin", "win32"; "x64", "arm64"). No normalization.
+	return `QwenCode/${version} (${process.platform}; ${process.arch})`;
+}
+
+/**
+ * Canonical DashScope Token Plan headers (upstream defaultHeaders, no caller
+ * overrides applied). Exposed for tests/fixtures so the pinned wire set lives
+ * in exactly one place.
+ */
+export function dashscopeTokenPlanDefaultHeaders(
+	version: string = QWEN_CODE_UPSTREAM_VERSION,
+): Readonly<Record<string, string>> {
+	const userAgent = qwenCodeUserAgent(version);
+	return Object.freeze({
+		"User-Agent": userAgent,
+		"X-DashScope-CacheControl": "enable",
+		"X-DashScope-UserAgent": userAgent,
+		"X-DashScope-AuthType": QWEN_CODE_TOKEN_PLAN_AUTH_TYPE,
+	});
+}
+
+/**
+ * Merge canonical DashScope Token Plan identity headers onto a caller's header
+ * map, reproducing upstream buildHeaders() precedence EXACTLY:
+ *   `{ ...defaultHeaders, ...customHeaders }` — caller wins per header.
+ *
+ * This mirrors GJC's existing kimi-code injection order
+ * (`headers = { ...getKimiCommonHeaders(), ...headers }`): canonical identity as
+ * the base, caller-supplied headers overriding individual keys. A caller that
+ * pins `User-Agent` takes that key; the other canonicals still apply.
+ *
+ * A null/undefined `callerHeaders` returns the canonical set alone (upstream
+ * `customHeaders ? {...} : defaultHeaders` shortcut).
+ */
+export function mergeDashScopeTokenPlanHeaders(
+	callerHeaders: Record<string, string> | undefined,
+	version: string = QWEN_CODE_UPSTREAM_VERSION,
+): Record<string, string> {
+	const defaults = dashscopeTokenPlanDefaultHeaders(version);
+	if (!callerHeaders) return { ...defaults };
+	return { ...defaults, ...callerHeaders };
+}

package/src/providers/gitlab-duo.ts

@@ -279,6 +279,7 @@ export function streamGitLabDuo(
 								sessionId: options.sessionId,
 								providerSessionState: options.providerSessionState,
 								onPayload: options.onPayload,
+								attemptScope: options?.attemptScope,
 								onResponse: options.onResponse,
 								onSseEvent: options.onSseEvent,
 								fetch: options.fetch,
@@ -316,6 +317,7 @@ export function streamGitLabDuo(
 									sessionId: options.sessionId,
 									providerSessionState: options.providerSessionState,
 									onPayload: options.onPayload,
+									attemptScope: options?.attemptScope,
 									onResponse: options.onResponse,
 									onSseEvent: options.onSseEvent,
 									fetch: options.fetch,
@@ -348,6 +350,7 @@ export function streamGitLabDuo(
 									sessionId: options.sessionId,
 									providerSessionState: options.providerSessionState,
 									onPayload: options.onPayload,
+									attemptScope: options?.attemptScope,
 									onResponse: options.onResponse,
 									onSseEvent: options.onSseEvent,
 									fetch: options.fetch,

package/src/providers/google-gemini-cli.ts

@@ -350,7 +350,7 @@ export const streamGoogleGeminiCli: StreamFunction<"google-gemini-cli"> = (
 			const endpoints = baseUrl ? [baseUrl] : isAntigravity ? ANTIGRAVITY_ENDPOINT_FALLBACKS : [DEFAULT_ENDPOINT];
 
 			let requestBody = buildRequest(model, context, projectId, options, isAntigravity);
-			const replacementPayload = await options?.onPayload?.(requestBody, model);
+			const replacementPayload = await options?.onPayload?.(requestBody, model, options?.attemptScope);
 			if (replacementPayload !== undefined) {
 				requestBody = replacementPayload as typeof requestBody;
 			}
@@ -483,7 +483,12 @@ export const streamGoogleGeminiCli: StreamFunction<"google-gemini-cli"> = (
 				for await (const chunk of readSseJson<CloudCodeAssistResponseChunk>(
 					activeResponse.body!,
 					options?.signal,
-					event => options?.onSseEvent?.({ event: event.event, data: event.data, raw: [...event.raw] }, model),
+					event =>
+						options?.onSseEvent?.(
+							{ event: event.event, data: event.data, raw: [...event.raw] },
+							model,
+							options?.attemptScope,
+						),
 				)) {
 					const responseData = chunk.response;
 					if (!responseData) continue;

package/src/providers/google-shared.ts

@@ -835,7 +835,7 @@ export function streamGoogleGenAI<T extends "google-generative-ai" | "google-ver
 		try {
 			const plan = await prepare();
 			let params = plan.params;
-			const replacement = await options?.onPayload?.(params, model);
+			const replacement = await options?.onPayload?.(params, model, options?.attemptScope);
 			if (replacement !== undefined) {
 				params = replacement as GenerateContentParameters;
 			}
@@ -915,7 +915,11 @@ export function streamGoogleGenAI<T extends "google-generative-ai" | "google-ver
 			}
 
 			const googleStream = readSseJson<GenerateContentResponse>(response.body, options?.signal, event =>
-				options?.onSseEvent?.({ event: event.event, data: event.data, raw: [...event.raw] }, model),
+				options?.onSseEvent?.(
+					{ event: event.event, data: event.data, raw: [...event.raw] },
+					model,
+					options?.attemptScope,
+				),
 			);
 
 			stream.push({ type: "start", partial: output });

package/src/providers/mock.ts

@@ -327,6 +327,7 @@ async function runMock(
 					...(response.responseRequestId !== undefined ? { requestId: response.responseRequestId } : {}),
 				},
 				model,
+				options.attemptScope,
 			);
 		} catch (err) {
 			stream.fail(err);

package/src/providers/ollama.ts

@@ -406,7 +406,7 @@ export const streamOllama: StreamFunction<"ollama-chat"> = (
 			const baseUrl = normalizeBaseUrl(model.baseUrl);
 			let body = createChatBody(model, context, options);
 			const sentForcedToolChoice = body.tool_choice === "required";
-			const replacementPayload = await options.onPayload?.(body, model);
+			const replacementPayload = await options.onPayload?.(body, model, options?.attemptScope);
 			if (replacementPayload !== undefined) {
 				body = replacementPayload as typeof body;
 			}

package/src/providers/openai-anthropic-shim.ts

@@ -86,6 +86,7 @@ export function streamOpenAIAnthropicShim(
 					headers: mergedHeaders,
 					sessionId: options?.sessionId,
 					onPayload: options?.onPayload,
+					attemptScope: options?.attemptScope,
 					onResponse: options?.onResponse,
 					onSseEvent: options?.onSseEvent,
 					fetch: options?.fetch,
@@ -117,6 +118,7 @@ export function streamOpenAIAnthropicShim(
 					headers: mergedHeaders,
 					sessionId: options?.sessionId,
 					onPayload: options?.onPayload,
+					attemptScope: options?.attemptScope,
 					onResponse: options?.onResponse,
 					onSseEvent: options?.onSseEvent,
 					fetch: options?.fetch,

package/src/providers/openai-codex-responses.ts

@@ -43,6 +43,7 @@ import {
 	createOpenAIResponsesHistoryPayload,
 	getOpenAIResponsesHistoryItems,
 	getOpenAIResponsesHistoryPayload,
+	neutralizeReservedControlTokens,
 	neutralizeResponsesInputControlTokens,
 	normalizeSystemPrompts,
 	sanitizeOpenAIResponsesHistoryItemsForReplay,
@@ -646,7 +647,7 @@ async function buildCodexRequestContext(
 	const url = resolveCodexResponsesUrl(baseUrl);
 	const promptCacheKey = normalizeOpenAIResponsesPromptCacheKey(options?.sessionId);
 	const transformedBody = await buildTransformedCodexRequestBody(model, context, options);
-	options?.onPayload?.(transformedBody);
+	options?.onPayload?.(transformedBody, model, options?.attemptScope);
 
 	const requestHeaders = { ...(model.headers ?? {}), ...(options?.headers ?? {}) };
 	const rawRequestDump: RawHttpRequestDump = {
@@ -746,7 +747,12 @@ async function buildTransformedCodexRequestBody(
 		}
 	}
 
-	const systemPrompts = normalizeSystemPrompts(context.systemPrompt);
+	// Neutralize leaked Harmony control tokens in the system prompt too:
+	// `params.instructions` and the developer messages prepended inside
+	// `transformRequestBody` bypass the `input` sanitizer above, so a poisoned
+	// system prompt rejects every turn with
+	// `Request blocked (code=invalid_prompt)`.
+	const systemPrompts = normalizeSystemPrompts(context.systemPrompt).map(neutralizeReservedControlTokens);
 	if (systemPrompts.length > 0) {
 		params.instructions = systemPrompts[0];
 	}
@@ -875,7 +881,7 @@ async function openCodexSseTransport(
 			body,
 			state,
 			requestSetup.requestSignal,
-			event => options?.onSseEvent?.(event, model),
+			event => options?.onSseEvent?.(event, model, options?.attemptScope),
 			options?.fetch,
 			options,
 		),

package/src/providers/openai-completions.ts

@@ -68,6 +68,7 @@ import {
 	resolveToolChoice,
 } from "../utils/tool-choice-capability";
 import { COMPOSER_EDIT_DISCIPLINE_PROMPT, isComposerHarnessModel } from "./composer-discipline";
+import { mergeDashScopeTokenPlanHeaders } from "./dashscope-token-plan-headers";
 import {
 	buildCopilotDynamicHeaders,
 	hasCopilotVisionInput,
@@ -481,6 +482,7 @@ export const streamOpenAICompletions: StreamFunction<"openai-completions"> = (
 				options?.requestMaxRetries,
 				options?.sessionId,
 				options?.maxRetryDelayMs,
+				options?.attemptScope,
 			);
 			const premiumRequestsTotal = copilotPremiumRequests;
 			getCapturedErrorResponse = captureErrorResponse;
@@ -503,7 +505,7 @@ export const streamOpenAICompletions: StreamFunction<"openai-completions"> = (
 					effectiveToolStrictModeOverride,
 				);
 				appliedToolStrictMode = toolStrictMode;
-				options?.onPayload?.(params);
+				options?.onPayload?.(params, undefined, options?.attemptScope);
 				rawRequestDump = {
 					provider: model.provider,
 					api: output.api,
@@ -1022,6 +1024,7 @@ async function createClient(
 	requestMaxRetries?: number,
 	sessionId?: string,
 	maxRetryDelayMs?: number,
+	attemptScope?: import("../types.js").AttemptScopeRef,
 ): Promise<{
 	client: OpenAI;
 	copilotPremiumRequests: number | undefined;
@@ -1071,6 +1074,14 @@ async function createClient(
 	if (model.provider === "kimi-code") {
 		headers = { ...getKimiCommonHeaders(), ...headers };
 	}
+	if (model.provider === "alibaba-token-plan") {
+		// Emit Qwen Code's canonical DashScope request fingerprint (User-Agent /
+		// X-DashScope-CacheControl / X-DashScope-UserAgent / X-DashScope-AuthType)
+		// so DashScope treats the caller identically to upstream QwenLM/qwen-code.
+		// Canonical identity is the base; caller headers win per key (upstream
+		// `{...default, ...customHeaders}`). #3557.
+		headers = mergeDashScopeTokenPlanHeaders(headers);
+	}
 	headers = applyOpenAIRequestTransformHeaders(headers, model.requestTransform, `Gajae-Code/${packageJson.version}`);
 	let copilotPremiumRequests: number | undefined;
 
@@ -1136,7 +1147,7 @@ async function createClient(
 		`Gajae-Code/${packageJson.version}`,
 	);
 	const debugFetch = onSseEvent
-		? wrapFetchForSseDebug(transformedFetch, event => onSseEvent(event, model))
+		? wrapFetchForSseDebug(transformedFetch, event => onSseEvent(event, model, attemptScope))
 		: transformedFetch;
 	// Bound HTTP request timeout to roughly the first-event watchdog window.
 	// The OpenAI SDK's default is 10 minutes per attempt × `maxRetries`, which

package/src/providers/openai-responses.ts

@@ -27,6 +27,7 @@ import {
 	getOpenAIResponsesHistoryItems,
 	getOpenAIResponsesHistoryPayload,
 	isInvalidPromptError,
+	neutralizeReservedControlTokens,
 	neutralizeResponsesInputControlTokens,
 	normalizeSystemPrompts,
 	resolveCacheRetention,
@@ -60,6 +61,7 @@ import {
 	resolveToolChoice,
 } from "../utils/tool-choice-capability";
 import { COMPOSER_EDIT_DISCIPLINE_PROMPT, isComposerHarnessModel } from "./composer-discipline";
+import { mergeDashScopeTokenPlanHeaders } from "./dashscope-token-plan-headers";
 import {
 	buildCopilotDynamicHeaders,
 	hasCopilotVisionInput,
@@ -282,12 +284,13 @@ export const streamOpenAIResponses: StreamFunction<"openai-responses"> = (
 				options?.authCredentialType,
 				options?.requestMaxRetries,
 				options?.maxRetryDelayMs,
+				options?.attemptScope,
 			);
 			const premiumRequestsTotal = copilotPremiumRequests;
 			const providerSessionState = getOpenAIResponsesProviderSessionState(model, options?.providerSessionState);
 			const { params } = buildParams(model, context, options, providerSessionState, baseUrl);
 			const idleTimeoutMs = options?.streamIdleTimeoutMs ?? getOpenAIStreamIdleTimeoutMs();
-			options?.onPayload?.(params);
+			options?.onPayload?.(params, undefined, options?.attemptScope);
 			rawRequestDump = {
 				provider: model.provider,
 				api: output.api,
@@ -431,6 +434,7 @@ function createClient(
 	authCredentialType?: OpenAIResponsesOptions["authCredentialType"],
 	requestMaxRetries?: number,
 	maxRetryDelayMs?: number,
+	attemptScope?: import("../types.js").AttemptScopeRef,
 ): {
 	client: OpenAI;
 	copilotPremiumRequests: number | undefined;
@@ -446,8 +450,17 @@ function createClient(
 	}
 	const rawApiKey = apiKey;
 
+	const baseHeaders =
+		model.provider === "alibaba-token-plan"
+			? // Emit Qwen Code's canonical DashScope request fingerprint (User-Agent /
+				// X-DashScope-CacheControl / X-DashScope-UserAgent / X-DashScope-AuthType)
+				// so DashScope treats the caller identically to upstream QwenLM/qwen-code.
+				// Canonical identity is the base; caller headers win per key (upstream
+				// `{...default, ...customHeaders}`). #3557.
+				mergeDashScopeTokenPlanHeaders({ ...(model.headers ?? {}), ...(extraHeaders ?? {}) })
+			: { ...(model.headers ?? {}), ...(extraHeaders ?? {}) };
 	const headers = applyOpenAIRequestTransformHeaders(
-		{ ...(model.headers ?? {}), ...(extraHeaders ?? {}) },
+		baseHeaders,
 		model.requestTransform,
 		`Gajae-Code/${packageJson.version}`,
 	);
@@ -491,7 +504,7 @@ function createClient(
 			maxRetries: resolveRetryBudget(requestMaxRetries, 5),
 			defaultHeaders: headers,
 			fetch: onSseEvent
-				? wrapFetchForSseDebug(transformedFetch, event => onSseEvent(event, model))
+				? wrapFetchForSseDebug(transformedFetch, event => onSseEvent(event, model, attemptScope))
 				: transformedFetch,
 		}),
 		copilotPremiumRequests,
@@ -523,7 +536,13 @@ function buildParams(
 	);
 	const messages: ResponseInput = neutralizeResponsesInputControlTokens(conversationMessages);
 
-	const systemPrompts = normalizeSystemPrompts(context.systemPrompt);
+	// Neutralize leaked Harmony control tokens in the system prompt too: the
+	// `instructions` field and developer-role messages bypass the `input`
+	// request-boundary sanitizer above, and a poisoned system prompt (e.g.
+	// injected project context quoting `<|channel|>` markers) rejects EVERY
+	// turn with `Request blocked (code=invalid_prompt)` — unrepairable by the
+	// history circuit breaker.
+	const systemPrompts = normalizeSystemPrompts(context.systemPrompt).map(neutralizeReservedControlTokens);
 	if (isComposerHarnessModel(model.id)) {
 		systemPrompts.unshift(COMPOSER_EDIT_DISCIPLINE_PROMPT);
 	}

package/src/stream.ts

@@ -705,6 +705,7 @@ function mapOptionsForApi<TApi extends Api>(
 		onPayload: options?.onPayload,
 		onResponse: options?.onResponse,
 		onSseEvent: options?.onSseEvent,
+		attemptScope: options?.attemptScope,
 		execHandlers: options?.execHandlers,
 		[managedAttemptValidated]: hasValidatedManagedAttempt(options),
 	};

package/src/types.ts

@@ -385,19 +385,29 @@ export interface StreamOptions {
 	/**
 	 * Optional callback for inspecting or replacing provider payloads before sending.
 	 * Return undefined to keep the payload unchanged.
+	 * The `scope` parameter carries the per-attempt identity for execution attribution.
 	 */
-	onPayload?: (payload: unknown, model?: Model<Api>) => unknown | undefined | Promise<unknown | undefined>;
+	onPayload?: (
+		payload: unknown,
+		model?: Model<Api>,
+		scope?: AttemptScopeRef,
+	) => unknown | undefined | Promise<unknown | undefined>;
 	/**
 	 * Optional callback for provider response metadata after headers are received.
+	 * The `scope` parameter carries the per-attempt identity for execution attribution.
 	 */
-	onResponse?: (response: ProviderResponseMetadata, model?: Model<Api>) => void | Promise<void>;
+	onResponse?: (
+		response: ProviderResponseMetadata,
+		model?: Model<Api>,
+		scope?: AttemptScopeRef,
+	) => void | Promise<void>;
 	/**
 	 * Optional callback for raw Server-Sent Events as they arrive from HTTP streaming providers.
 	 *
 	 * Diagnostic only: provider implementations must ignore callback failures and must not
 	 * let observers alter stream contents.
 	 */
-	onSseEvent?: (event: RawSseEvent, model?: Model<Api>) => void;
+	onSseEvent?: (event: RawSseEvent, model?: Model<Api>, scope?: AttemptScopeRef) => void;
 	/**
 	 * Optional override for the first streamed event watchdog in milliseconds.
 	 * Set to 0 to disable the first-event watchdog for this request.
@@ -427,6 +437,23 @@ export interface StreamOptions {
 	authCredentialType?: "api_key" | "oauth";
 	/** Cursor exec/MCP tool handlers (cursor-agent only). */
 	execHandlers?: CursorExecHandlers;
+	/** Per-attempt identity for execution attribution. Threaded into onPayload/onResponse calls. */
+	attemptScope?: AttemptScopeRef;
+}
+
+/**
+ * Low-level structural carrier for per-attempt identity attribution.
+ *
+ * Defined in `packages/ai` so that {@link SimpleStreamOptions} and provider
+ * hook signatures can carry an attempt identity without a reverse dependency
+ * on `packages/agent`. The concrete `AttemptScope` in `packages/agent` is
+ * structurally assignable to this interface (same `attemptId` + `generation`
+ * + `lineage` fields).
+ */
+export interface AttemptScopeRef {
+	readonly attemptId: string;
+	readonly generation: number;
+	readonly lineage: string;
 }
 
 // Unified options with reasoning passed to streamSimple() and completeSimple()

package/src/utils/provider-response.ts

@@ -1,4 +1,4 @@
-import type { Api, Model, ProviderResponseMetadata, StreamOptions } from "../types";
+import type { Api, AttemptScopeRef, Model, ProviderResponseMetadata, StreamOptions } from "../types";
 
 export function normalizeProviderResponse(
 	response: Response,
@@ -19,12 +19,12 @@ export function normalizeProviderResponse(
 }
 
 export async function notifyProviderResponse(
-	options: Pick<StreamOptions, "onResponse"> | undefined,
+	options: { onResponse?: StreamOptions["onResponse"]; attemptScope?: AttemptScopeRef } | undefined,
 	response: Response,
 	model?: Model<Api>,
 	requestId?: string | null,
 	metadata?: Record<string, unknown>,
 ): Promise<void> {
 	if (!options?.onResponse) return;
-	await options.onResponse(normalizeProviderResponse(response, requestId, metadata), model);
+	await options.onResponse(normalizeProviderResponse(response, requestId, metadata), model, options.attemptScope);
 }