@gajae-code/ai 0.17.4 → 0.17.6

package/src/providers/kiro-api-key.ts

@@ -230,6 +230,13 @@ const STATIC_KIRO_API_CATALOG: Array<{
 		maxOutputTokens: 128_000,
 		image: true,
 	},
+	{
+		modelId: "claude-opus-5.5",
+		modelName: "Claude Opus 5.5",
+		maxInputTokens: 1_000_000,
+		maxOutputTokens: 128_000,
+		image: false,
+	},
 	{
 		modelId: "gpt-5.6-luna",
 		modelName: "GPT 5.6 Luna",

package/src/providers/openai-completions.ts

@@ -8,6 +8,7 @@ import type {
 	ChatCompletionContentPartImage,
 	ChatCompletionContentPartText,
 	ChatCompletionMessageParam,
+	ChatCompletionToolChoiceOption,
 	ChatCompletionToolMessageParam,
 } from "openai/resources/chat/completions";
 import packageJson from "../../package.json" with { type: "json" };
@@ -1884,25 +1885,6 @@ function buildParams(
 		params.reasoning_effort = mapReasoningEffort(minEffort, compat.reasoningEffortMap) as Effort;
 	}
 
-	if (compat.disableReasoningOnToolChoice && params.tool_choice !== undefined) {
-		// DeepSeek reasoning models accept tools/tool_choice, but reject that
-		// control field while thinking is enabled. Keep the tool-selection
-		// contract and suppress reasoning for this single request.
-		delete params.reasoning_effort;
-		delete params.reasoning;
-	}
-
-	if (compat.disableReasoningOnForcedToolChoice && isForcedToolChoice(params.tool_choice)) {
-		// Backends like Kimi 400 with `tool_choice 'specified' is incompatible
-		// with thinking enabled`. Suppress thinking for this single forced-tool
-		// turn while keeping the tool-selection contract intact.
-		delete params.reasoning_effort;
-		delete params.reasoning;
-		if (compat.thinkingFormat === "zai") {
-			params.thinking = { type: "disabled" };
-		}
-	}
-
 	// OpenRouter provider routing preferences
 	if (model.baseUrl.includes("openrouter.ai") && compat.openRouterRouting) {
 		params.provider = compat.openRouterRouting;
@@ -1922,13 +1904,46 @@ function buildParams(
 	if (compat.extraBody) {
 		// The resolved output limit owns the selected wire field; extraBody is a
 		// free-form compatibility escape hatch and must not add a competing
-		// max-token field or overwrite the resolved budget.
-		const { max_tokens, max_completion_tokens, max_output_tokens, ...restExtra } = compat.extraBody as Record<
-			string,
-			unknown
-		>;
+		// max-token field or overwrite the resolved budget. tool_choice follows
+		// the same discipline on both sides: an injected default (an endpoint
+		// whose tool_choice default is "none", like IO Intelligence, would
+		// otherwise stop tool calls) may only fill the gap on an ordinary turn
+		// that offers tools but resolved no directive of its own. Explicit
+		// directives — forced tools, retry reminders — stay untouched, and
+		// turns that deliberately carry no tools keep their stripped shape
+		// instead of re-adding tool_choice with an empty tools list.
+		const { max_tokens, max_completion_tokens, max_output_tokens, tool_choice, ...restExtra } =
+			compat.extraBody as Record<string, unknown>;
+		if (
+			tool_choice !== undefined &&
+			params.tool_choice === undefined &&
+			Array.isArray(params.tools) &&
+			params.tools.length > 0
+		) {
+			params.tool_choice = tool_choice as ChatCompletionToolChoiceOption;
+		}
 		Object.assign(params, restExtra);
 	}
+
+	if (compat.disableReasoningOnToolChoice && params.tool_choice !== undefined) {
+		// DeepSeek reasoning models accept tools/tool_choice, but reject that
+		// control field while thinking is enabled. Keep the tool-selection
+		// contract and suppress reasoning for this single request.
+		delete params.reasoning_effort;
+		delete params.reasoning;
+	}
+
+	if (compat.disableReasoningOnForcedToolChoice && isForcedToolChoice(params.tool_choice)) {
+		// Backends like Kimi 400 with `tool_choice 'specified' is incompatible
+		// with thinking enabled`. Suppress thinking for this single forced-tool
+		// turn while keeping the tool-selection contract intact.
+		delete params.reasoning_effort;
+		delete params.reasoning;
+		if (compat.thinkingFormat === "zai") {
+			params.thinking = { type: "disabled" };
+		}
+	}
+
 	applyOpenAIRequestTransformBody(params, model.requestTransform);
 	if (!supportsReasoningParams) {
 		delete params.reasoning;

package/src/providers/transform-messages.ts

@@ -85,6 +85,59 @@ function collapseAdjacentThinking<T extends { type: string }>(content: T[]): T[]
 	return dropped ? collapsed : content;
 }
 
+const MIN_CROSS_MODEL_THINKING_REPEAT_COUNT = 64;
+const MIN_CROSS_MODEL_THINKING_REPEAT_SAVED_CHARACTERS = 4_096;
+
+/**
+ * Bound pathological cross-model reasoning replay without editing the stored
+ * thinking block. Only exact adjacent non-empty paragraphs qualify, and the
+ * threshold requires both a large run and substantial net savings.
+ */
+function compressRepeatedThinkingParagraphs(thinking: string): string {
+	const parts = thinking.split(/(\r?\n(?:[ \t]*\r?\n)+)/);
+	const compressedParts: string[] = [];
+	let compressed = false;
+
+	for (let paragraphIndex = 0; paragraphIndex < parts.length; ) {
+		const paragraph = parts[paragraphIndex];
+		let runEnd = paragraphIndex;
+		while (runEnd + 2 < parts.length && parts[runEnd + 2] === paragraph) {
+			runEnd += 2;
+		}
+
+		const repeatCount = (runEnd - paragraphIndex) / 2 + 1;
+		let marker: string | undefined;
+		let savedCharacters = 0;
+		if (paragraph.length > 0 && repeatCount >= MIN_CROSS_MODEL_THINKING_REPEAT_COUNT) {
+			marker = `[Repeated paragraph occurred exactly ${repeatCount} consecutive times; only its first occurrence is shown.]`;
+			savedCharacters = (repeatCount - 1) * paragraph.length - marker.length;
+			for (let separatorIndex = paragraphIndex + 3; separatorIndex < runEnd; separatorIndex += 2) {
+				savedCharacters += parts[separatorIndex].length;
+			}
+		}
+
+		if (marker !== undefined && savedCharacters >= MIN_CROSS_MODEL_THINKING_REPEAT_SAVED_CHARACTERS) {
+			compressedParts.push(paragraph);
+			if (paragraphIndex + 1 < parts.length) compressedParts.push(parts[paragraphIndex + 1]);
+			compressedParts.push(marker);
+			compressed = true;
+		} else {
+			for (let partIndex = paragraphIndex; partIndex <= runEnd; partIndex++) {
+				compressedParts.push(parts[partIndex]);
+			}
+		}
+
+		// The separator after the run belongs to the next paragraph and must
+		// survive verbatim, regardless of whether this run was compressed.
+		if (runEnd + 1 < parts.length) {
+			compressedParts.push(parts[runEnd + 1]);
+		}
+		paragraphIndex = runEnd + 2;
+	}
+
+	return compressed ? compressedParts.join("") : thinking;
+}
+
 export function transformMessages<TApi extends Api>(
 	messages: Message[],
 	model: Model<TApi>,
@@ -170,7 +223,7 @@ export function transformMessages<TApi extends Api>(
 					if (isSameModel) return sanitized;
 					return {
 						type: "text" as const,
-						text: sanitized.thinking,
+						text: compressRepeatedThinkingParagraphs(sanitized.thinking),
 					};
 				}