@gajae-code/ai 0.2.0 → 0.2.2

package/src/provider-models/descriptors.ts

@@ -295,6 +295,7 @@ export const PROVIDER_DESCRIPTORS: readonly ProviderDescriptor[] = [
 export const DEFAULT_MODEL_PER_PROVIDER: Record<KnownProvider, string> = {
 	...Object.fromEntries(PROVIDER_DESCRIPTORS.map(d => [d.providerId, d.defaultModel])),
 	// Providers not in PROVIDER_DESCRIPTORS (special auth or no standard discovery)
+	"azure-openai": "gpt-4.1",
 	"alibaba-coding-plan": "qwen3.5-plus",
 	"amazon-bedrock": "us.anthropic.claude-opus-4-6-v1",
 	"google-antigravity": "gemini-3-pro-high",

package/src/providers/anthropic.ts

@@ -304,6 +304,17 @@ export function isAnthropicFastModeUnsupportedError(error: unknown): boolean {
 	return false;
 }
 
+export function isAnthropicThinkingBlockMutationError(error: unknown): boolean {
+	if (extractHttpStatusFromError(error) !== 400) return false;
+	const message = error instanceof Error ? error.message : String(error);
+	return (
+		/invalid_request_error/i.test(message) &&
+		/thinking|redacted_thinking/i.test(message) &&
+		/latest assistant message/i.test(message) &&
+		/cannot be modified/i.test(message)
+	);
+}
+
 function hasStrictAnthropicTools(params: MessageCreateParamsStreaming): boolean {
 	const tools = params.tools as Array<{ strict?: unknown }> | undefined;
 	return tools?.some(tool => tool.strict === true) ?? false;
@@ -1058,8 +1069,18 @@ export const streamAnthropic: StreamFunction<"anthropic-messages"> = (
 				(providerSessionState?.strictToolsDisabled ?? false) || (model.compat?.disableStrictTools ?? false);
 			let strictFallbackErrorMessage: string | undefined;
 			let dropFastMode = providerSessionState?.fastModeDisabled ?? false;
-			const prepareParams = async (): Promise<MessageCreateParamsStreaming> => {
-				let nextParams = buildParams(model, baseUrl, context, isOAuthToken, options, disableStrictTools);
+			const prepareParams = async (paramsOptions?: {
+				repairLatestAssistantThinking?: boolean;
+			}): Promise<MessageCreateParamsStreaming> => {
+				let nextParams = buildParams(
+					model,
+					baseUrl,
+					context,
+					isOAuthToken,
+					options,
+					disableStrictTools,
+					paramsOptions?.repairLatestAssistantThinking === true,
+				);
 				if (disableStrictTools) {
 					dropAnthropicStrictTools(nextParams);
 				}
@@ -1096,6 +1117,7 @@ export const streamAnthropic: StreamFunction<"anthropic-messages"> = (
 			// Provider-level transport/rate-limit failures: only before any streamed content starts.
 			// Malformed envelopes/JSON: only before replay-unsafe text/tool events are visible on this stream.
 			let providerRetryAttempt = 0;
+			let thinkingRepairAttempted = false;
 			while (true) {
 				activeAbortTracker = createAbortSourceTracker(options?.signal);
 				const firstEventTimeoutAbortError = new Error(
@@ -1372,6 +1394,26 @@ export const streamAnthropic: StreamFunction<"anthropic-messages"> = (
 						firstTokenTime = undefined;
 						continue;
 					}
+					if (
+						!thinkingRepairAttempted &&
+						firstTokenTime === undefined &&
+						isAnthropicThinkingBlockMutationError(streamFailure)
+					) {
+						logger.debug("anthropic: repairing latest assistant thinking replay after provider rejection", {
+							model: model.id,
+							error: streamFailure instanceof Error ? streamFailure.message : String(streamFailure),
+						});
+						thinkingRepairAttempted = true;
+						params = await prepareParams({ repairLatestAssistantThinking: true });
+						providerRetryAttempt = 0;
+						output.content.length = 0;
+						output.responseId = undefined;
+						output.providerPayload = undefined;
+						output.usage = createEmptyUsage(copilotDynamicHeaders?.premiumRequests);
+						output.stopReason = "stop";
+						firstTokenTime = undefined;
+						continue;
+					}
 					if (
 						!dropFastMode &&
 						resolveServiceTier(options?.serviceTier, model.provider) === "priority" &&
@@ -1887,11 +1929,12 @@ function buildParams(
 	isOAuthToken: boolean,
 	options?: AnthropicOptions,
 	disableStrictTools = false,
+	repairLatestAssistantThinking = false,
 ): MessageCreateParamsStreaming {
 	const { cacheControl } = getCacheControl(model, baseUrl, options?.cacheRetention);
 	const params: AnthropicSamplingParams = {
 		model: model.id,
-		messages: convertAnthropicMessages(context.messages, model, isOAuthToken),
+		messages: convertAnthropicMessages(context.messages, model, isOAuthToken, { repairLatestAssistantThinking }),
 		max_tokens: options?.maxTokens || (model.maxTokens / 3) | 0,
 		stream: true,
 	};
@@ -2074,10 +2117,11 @@ export function convertAnthropicMessages(
 	messages: Message[],
 	model: Model<"anthropic-messages">,
 	isOAuthToken: boolean,
+	options?: { repairLatestAssistantThinking?: boolean },
 ): MessageParam[] {
 	const params: MessageParam[] = [];
 
-	const transformedMessages = transformMessages(messages, model, normalizeToolCallId);
+	const transformedMessages = transformMessages(messages, model, normalizeToolCallId, options);
 
 	for (let i = 0; i < transformedMessages.length; i++) {
 		const msg = transformedMessages[i];

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

@@ -4,7 +4,7 @@
  * GeminiCLI/VERSION/MODEL (PLATFORM; ARCH; SURFACE)
  */
 export function getGeminiCliUserAgent(modelId = "gemini-3.1-pro-preview"): string {
-	const version = process.env.PI_AI_GEMINI_CLI_VERSION || "0.35.3";
+	const version = process.env.PI_AI_GEMINI_CLI_VERSION || "0.44.1";
 	const platform = process.platform === "win32" ? "win32" : process.platform;
 	const arch = process.arch === "x64" ? "x64" : process.arch;
 	return `GeminiCLI/${version}/${modelId} (${platform}; ${arch}; terminal)`;

package/src/providers/openai-completions.ts

@@ -66,6 +66,11 @@ import {
 	resolveGitHubCopilotBaseUrl,
 } from "./github-copilot-headers";
 import { detectOpenAICompat, type ResolvedOpenAICompat, resolveOpenAICompat } from "./openai-completions-compat";
+import {
+	applyOpenAIRequestTransformBody,
+	applyOpenAIRequestTransformHeaders,
+	wrapFetchForOpenAIRequestTransform,
+} from "./openai-request-transform";
 import { createInitialResponsesAssistantMessage } from "./openai-responses-shared";
 import { transformMessages } from "./transform-messages";
 import { joinTextWithImagePlaceholder, NON_VISION_IMAGE_PLACEHOLDER } from "./vision-guard";
@@ -956,6 +961,7 @@ async function createClient(
 	if (model.provider === "kimi-code") {
 		headers = { ...getKimiCommonHeaders(), ...headers };
 	}
+	headers = applyOpenAIRequestTransformHeaders(headers, model.requestTransform, `Gajae-Code/${packageJson.version}`);
 	let copilotPremiumRequests: number | undefined;
 
 	let baseUrl =
@@ -1013,7 +1019,14 @@ async function createClient(
 		},
 		baseFetch.preconnect ? { preconnect: baseFetch.preconnect } : {},
 	);
-	const debugFetch = onSseEvent ? wrapFetchForSseDebug(wrappedFetch, event => onSseEvent(event, model)) : wrappedFetch;
+	const transformedFetch = wrapFetchForOpenAIRequestTransform(
+		wrappedFetch,
+		model.requestTransform,
+		`Gajae-Code/${packageJson.version}`,
+	);
+	const debugFetch = onSseEvent
+		? wrapFetchForSseDebug(transformedFetch, event => onSseEvent(event, model))
+		: transformedFetch;
 	// Bound HTTP request timeout to roughly the first-event watchdog window.
 	// The OpenAI SDK's default is 10 minutes per attempt × `maxRetries`, which
 	// turns a stalled-before-headers fetch into a multi-minute hang invisible
@@ -1078,11 +1091,12 @@ function buildParams(
 	const effectiveMaxTokens = options?.maxTokens ?? (isKimi ? model.maxTokens : undefined);
 
 	const requestModelId =
-		model.provider === "fireworks"
+		model.wireModelId ??
+		(model.provider === "fireworks"
 			? toFireworksWireModelId(model.id)
 			: model.provider === "firepass"
 				? toFirepassWireModelId(model.id)
-				: model.id;
+				: model.id);
 	const params: OpenAICompletionsParams = {
 		model: requestModelId,
 		messages,
@@ -1260,6 +1274,7 @@ function buildParams(
 	if (compat.extraBody) {
 		Object.assign(params, compat.extraBody);
 	}
+	applyOpenAIRequestTransformBody(params, model.requestTransform);
 
 	return { params, toolStrictMode };
 }

package/src/providers/openai-request-transform.ts

@@ -0,0 +1,135 @@
+import type { FetchImpl, ModelRequestTransform } from "../types";
+
+const PROTECTED_EXTRA_BODY_KEYS = new Set([
+	"model",
+	"messages",
+	"input",
+	"instructions",
+	"stream",
+	"stream_options",
+	"store",
+	"max_tokens",
+	"max_completion_tokens",
+	"max_output_tokens",
+	"temperature",
+	"top_p",
+	"presence_penalty",
+	"frequency_penalty",
+	"reasoning",
+	"reasoning_effort",
+	"prompt_cache_key",
+	"prompt_cache_retention",
+	"service_tier",
+	"stop",
+	"tools",
+	"tool_choice",
+	"parallel_tool_calls",
+]);
+
+const OPENAI_PROXY_STRIP_HEADERS = [
+	"x-stainless-arch",
+	"x-stainless-async",
+	"x-stainless-lang",
+	"x-stainless-os",
+	"x-stainless-package-version",
+	"x-stainless-retry-count",
+	"x-stainless-runtime",
+	"x-stainless-runtime-version",
+	"x-stainless-timeout",
+	"x-stainless-helper-method",
+	"openai-organization",
+	"openai-project",
+] as const;
+
+function resolveRequestTransform(
+	transform: ModelRequestTransform | undefined,
+	profileUserAgent: string,
+): ModelRequestTransform | undefined {
+	if (!transform) return undefined;
+	const profileTransform: ModelRequestTransform =
+		transform.profile === "openai-proxy"
+			? {
+					stripHeaders: [...OPENAI_PROXY_STRIP_HEADERS],
+					setHeaders: { "User-Agent": profileUserAgent },
+				}
+			: {};
+	return {
+		...profileTransform,
+		...transform,
+		stripHeaders: transform.stripHeaders ?? profileTransform.stripHeaders,
+		setHeaders: transform.setHeaders
+			? { ...(profileTransform.setHeaders ?? {}), ...transform.setHeaders }
+			: profileTransform.setHeaders,
+		extraBody: transform.extraBody,
+	};
+}
+
+function deleteHeaders(headers: Headers, names: readonly string[] | undefined): void {
+	for (const name of names ?? []) {
+		headers.delete(name);
+	}
+}
+
+function setHeaders(headers: Headers, values: Record<string, string | null> | undefined): void {
+	for (const [name, value] of Object.entries(values ?? {})) {
+		if (value === null) {
+			headers.delete(name);
+		} else {
+			headers.set(name, value);
+		}
+	}
+}
+
+function transformHeaders(
+	headers: RequestInit["headers"] | undefined,
+	transform: ModelRequestTransform | undefined,
+): Headers {
+	const result = new Headers(headers);
+	deleteHeaders(result, transform?.stripHeaders);
+	setHeaders(result, transform?.setHeaders);
+	return result;
+}
+
+export function applyOpenAIRequestTransformHeaders(
+	headers: Record<string, string>,
+	transform: ModelRequestTransform | undefined,
+	profileUserAgent: string,
+): Record<string, string> {
+	const resolved = resolveRequestTransform(transform, profileUserAgent);
+	if (!resolved) return headers;
+	return Object.fromEntries(transformHeaders(headers, resolved).entries());
+}
+
+export function applyOpenAIRequestTransformBody(params: object, transform: ModelRequestTransform | undefined): void {
+	if (!transform?.extraBody) return;
+	const body = params as Record<string, unknown>;
+	for (const [key, value] of Object.entries(transform.extraBody)) {
+		if (!PROTECTED_EXTRA_BODY_KEYS.has(key) && !(key in body)) {
+			body[key] = value;
+		}
+	}
+}
+
+export function wrapFetchForOpenAIRequestTransform(
+	baseFetch: FetchImpl,
+	transform: ModelRequestTransform | undefined,
+	profileUserAgent: string,
+): FetchImpl {
+	const resolved = resolveRequestTransform(transform, profileUserAgent);
+	if (!resolved) return baseFetch;
+	return Object.assign(
+		async (input: string | URL | Request, init?: RequestInit): Promise<Response> => {
+			if (input instanceof Request) {
+				const request = new Request(input, init);
+				deleteHeaders(request.headers, resolved.stripHeaders);
+				setHeaders(request.headers, resolved.setHeaders);
+				return baseFetch(request);
+			}
+			return baseFetch(input, {
+				...init,
+				headers: transformHeaders(init?.headers, resolved),
+			});
+		},
+		baseFetch.preconnect ? { preconnect: baseFetch.preconnect } : {},
+	);
+}

package/src/providers/openai-responses.ts

@@ -5,6 +5,7 @@ import type {
 	ResponseCreateParamsStreaming,
 	ResponseInput,
 } from "openai/resources/responses/responses";
+import packageJson from "../../package.json" with { type: "json" };
 import { getEnvApiKey } from "../stream";
 import type {
 	AssistantMessage,
@@ -50,6 +51,11 @@ import {
 	resolveGitHubCopilotBaseUrl,
 } from "./github-copilot-headers";
 import { compactGrammarDefinition } from "./grammar";
+import {
+	applyOpenAIRequestTransformBody,
+	applyOpenAIRequestTransformHeaders,
+	wrapFetchForOpenAIRequestTransform,
+} from "./openai-request-transform";
 import {
 	appendResponsesToolResultMessages,
 	applyCommonResponsesSamplingParams,
@@ -363,7 +369,11 @@ function createClient(
 	}
 	const rawApiKey = apiKey;
 
-	const headers = { ...(model.headers ?? {}), ...(extraHeaders ?? {}) };
+	const headers = applyOpenAIRequestTransformHeaders(
+		{ ...(model.headers ?? {}), ...(extraHeaders ?? {}) },
+		model.requestTransform,
+		`Gajae-Code/${packageJson.version}`,
+	);
 	let copilotPremiumRequests: number | undefined;
 
 	let baseUrl =
@@ -390,6 +400,11 @@ function createClient(
 		headers["x-client-request-id"] ??= sessionId;
 	}
 	const baseFetch = fetchOverride ?? fetch;
+	const transformedFetch = wrapFetchForOpenAIRequestTransform(
+		baseFetch,
+		model.requestTransform,
+		`Gajae-Code/${packageJson.version}`,
+	);
 	return {
 		client: new OpenAI({
 			apiKey,
@@ -397,7 +412,9 @@ function createClient(
 			dangerouslyAllowBrowser: true,
 			maxRetries: 5,
 			defaultHeaders: headers,
-			fetch: onSseEvent ? wrapFetchForSseDebug(baseFetch, event => onSseEvent(event, model)) : baseFetch,
+			fetch: onSseEvent
+				? wrapFetchForSseDebug(transformedFetch, event => onSseEvent(event, model))
+				: transformedFetch,
 		}),
 		copilotPremiumRequests,
 		baseUrl,
@@ -453,7 +470,7 @@ function buildParams(
 	const cacheRetention = resolveCacheRetention(options?.cacheRetention);
 	const promptCacheKey = getOpenAIResponsesCacheSessionId(options);
 	const params: OpenAIResponsesSamplingParams = {
-		model: model.id,
+		model: model.wireModelId ?? model.id,
 		input: messages,
 		instructions: systemInstructions,
 		stream: true,
@@ -490,6 +507,7 @@ function buildParams(
 	applyResponsesReasoningParams(params, model, options, messages, effort =>
 		mapReasoningEffort(effort as NonNullable<OpenAIResponsesOptions["reasoning"]>, model.compat?.reasoningEffortMap),
 	);
+	applyOpenAIRequestTransformBody(params, model.requestTransform);
 
 	return { conversationMessages, params };
 }

package/src/providers/transform-messages.ts

@@ -31,6 +31,7 @@ export function transformMessages<TApi extends Api>(
 	messages: Message[],
 	model: Model<TApi>,
 	normalizeToolCallId?: (id: string, model: Model<TApi>, source: AssistantMessage) => string,
+	options?: { repairLatestAssistantThinking?: boolean },
 ): Message[] {
 	// Build a map of original tool call IDs to normalized IDs
 	const toolCallIdMap = new Map<string, string>();
@@ -64,16 +65,24 @@ export function transformMessages<TApi extends Api>(
 				index === latestAssistantIndex &&
 				model.api === "anthropic-messages" &&
 				assistantMsg.api === "anthropic-messages";
-			// Aborted/errored messages may have partially-streamed thinking signatures.
-			// A partial signature is invalid and will be rejected by the API, so we must
-			// strip signatures from thinking blocks in these messages.
-			const hasInvalidSignatures = assistantMsg.stopReason === "aborted" || assistantMsg.stopReason === "error";
+			// Aborted/errored messages may contain partially-streamed thinking blocks.
+			// Anthropic requires thinking/redacted_thinking bytes in replayed assistant
+			// messages to match the original response exactly; stripping a signature,
+			// well-forming text, or keeping a partial redacted block would emit a
+			// modified thinking sequence. Drop those private blocks instead. Tool calls
+			// are kept so the second pass can either preserve real results or synthesize
+			// an explicit aborted result without leaving dangling tool_use blocks.
+			const hasPartialThinking = assistantMsg.stopReason === "aborted" || assistantMsg.stopReason === "error";
+			const dropLatestAssistantThinking =
+				options?.repairLatestAssistantThinking === true &&
+				index === latestAssistantIndex &&
+				model.api === "anthropic-messages" &&
+				assistantMsg.api === "anthropic-messages";
 
 			const transformedContent = assistantMsg.content.flatMap(block => {
 				if (block.type === "thinking") {
-					// Strip signature from aborted/errored messages — it's likely incomplete
-					const sanitized =
-						hasInvalidSignatures && block.thinkingSignature ? { ...block, thinkingSignature: undefined } : block;
+					if (hasPartialThinking || dropLatestAssistantThinking) return [];
+					const sanitized = block;
 					if (mustPreserveLatestAnthropicThinking) return sanitized;
 					// For same model: keep thinking blocks with signatures (needed for replay)
 					// even if the thinking text is empty (OpenAI encrypted reasoning)
@@ -88,6 +97,7 @@ export function transformMessages<TApi extends Api>(
 				}
 
 				if (block.type === "redactedThinking") {
+					if (hasPartialThinking || dropLatestAssistantThinking) return [];
 					if (mustPreserveLatestAnthropicThinking) return block;
 					if (isSameModel) return block;
 					return [];

package/src/stream.ts

@@ -97,6 +97,7 @@ const serviceProviderMap: Record<string, KeyResolver> = {
 	cursor: "CURSOR_ACCESS_TOKEN",
 	deepseek: "DEEPSEEK_API_KEY",
 	"openai-codex": "OPENAI_CODEX_OAUTH_TOKEN",
+	"azure-openai": "AZURE_OPENAI_API_KEY",
 	"azure-openai-responses": "AZURE_OPENAI_API_KEY",
 	exa: "EXA_API_KEY",
 	jina: "JINA_API_KEY",

package/src/types.ts

@@ -98,6 +98,7 @@ export interface ThinkingConfig {
 export type KnownProvider =
 	| "alibaba-coding-plan"
 	| "amazon-bedrock"
+	| "azure-openai"
 	| "anthropic"
 	| "google"
 	| "google-gemini-cli"
@@ -823,6 +824,18 @@ export interface VercelGatewayRouting {
 }
 
 // Model interface for the unified model system
+
+export interface ModelRequestTransform {
+	/** Named request-shaping preset. `openai-proxy` removes OpenAI SDK telemetry headers and uses a generic Gajae-Code User-Agent. */
+	profile?: "openai-proxy";
+	/** Header names to remove from the final outbound request. Case-insensitive. */
+	stripHeaders?: string[];
+	/** Headers to set after stripping; use null to remove a header explicitly. */
+	setHeaders?: Record<string, string | null>;
+	/** Extra request body fields merged after provider defaults; protected core request keys are ignored. */
+	extraBody?: Record<string, unknown>;
+}
+
 export interface Model<TApi extends Api = any> {
 	id: string;
 	name: string;
@@ -861,6 +874,10 @@ export interface Model<TApi extends Api = any> {
 	preferWebsockets?: boolean;
 	/** Preferred model to switch to when context promotion is triggered (model id or provider/id). */
 	contextPromotionTarget?: string;
+	/** Provider-facing model id when it differs from the local selector id. */
+	wireModelId?: string;
+	/** Declarative request shaping for OpenAI-compatible proxy providers. */
+	requestTransform?: ModelRequestTransform;
 	/** Provider-assigned priority value (lower = higher priority). */
 	priority?: number;
 	/** Canonical thinking capability metadata for this model. */

package/src/utils/http-inspector.ts

@@ -102,9 +102,45 @@ function sanitizeDump(dump: RawHttpRequestDump): RawHttpRequestDump {
 	return {
 		...dump,
 		headers: redactHeaders(dump.headers),
+		body: sanitizeDumpBody(dump.body),
 	};
 }
 
+function sanitizeDumpBody(value: unknown): unknown {
+	if (Array.isArray(value)) {
+		return value.map(item => sanitizeDumpBody(item));
+	}
+	if (!isObject(value)) {
+		return value;
+	}
+
+	const type = typeof value.type === "string" ? value.type : undefined;
+	const redactedKeys = getRedactedBodyKeys(type);
+	const sanitized: Record<string, unknown> = {};
+	for (const [key, property] of Object.entries(value)) {
+		if (redactedKeys.has(key)) {
+			sanitized[key] = "[redacted]";
+			continue;
+		}
+		sanitized[key] = sanitizeDumpBody(property);
+	}
+	return sanitized;
+}
+
+function getRedactedBodyKeys(type: string | undefined): Set<string> {
+	const keys = new Set<string>();
+	if (type === "thinking") {
+		keys.add("thinking");
+		keys.add("signature");
+		keys.add("thinkingSignature");
+		keys.add("thoughtSignature");
+	}
+	if (type === "redacted_thinking" || type === "redactedThinking") {
+		keys.add("data");
+	}
+	return keys;
+}
+
 function redactHeaders(headers: Record<string, string> | undefined): Record<string, string> | undefined {
 	if (!headers) {
 		return undefined;