ghc-proxy 0.7.1 → 0.7.2

package/dist/main.mjs

@@ -7364,7 +7364,7 @@ const checkUsage = defineCommand({
 });
 //#endregion
 //#region src/util/version.ts
-const VERSION = "0.7.1";
+const VERSION = "0.7.2";
 //#endregion
 //#region src/debug.ts
 function getRuntimeInfo() {
@@ -48617,10 +48617,15 @@ const anthropicMcpToolUseBlockSchema = object({
 	input: jsonObjectSchema,
 	server_name: string().min(1)
 }).loose();
+const anthropicDocumentBlockSchema = object({
+	type: literal("document"),
+	source: jsonObjectSchema
+}).loose();
 const anthropicToolResultContentBlockSchema = union([
 	anthropicTextBlockSchema,
 	anthropicImageBlockSchema,
-	anthropicSearchResultBlockSchema
+	anthropicSearchResultBlockSchema,
+	anthropicDocumentBlockSchema
 ]);
 const anthropicToolResultBlockSchema = object({
 	type: literal("tool_result"),
@@ -48648,10 +48653,6 @@ const anthropicServerToolResultBlockSchema = object({
 	content: unknown(),
 	is_error: boolean().optional()
 }).loose();
-const anthropicDocumentBlockSchema = object({
-	type: literal("document"),
-	source: jsonObjectSchema
-}).loose();
 const anthropicMessageSchema = union([
 	object({
 		role: literal("user"),
@@ -49638,6 +49639,31 @@ function normalizeOutputConfigEffort(effort, model) {
 function hasOutputConfigFormat(payload) {
 	return payload?.output_config?.format != null;
 }
+function budgetTokensToEffort(budget) {
+	if (budget >= 24e3) return "high";
+	if (budget >= 8e3) return "medium";
+	return "low";
+}
+/**
+* Models whose upstream `/v1/messages` endpoint only accepts the adaptive
+* thinking API reject the classic `thinking.type: "enabled"` shape with a 400.
+* Convert `enabled` → `adaptive` (+ derive `output_config.effort` from the
+* requested `budget_tokens`) for those models before forwarding. Models that
+* do not advertise `adaptive_thinking` keep the classic `enabled` shape.
+*
+* Must run before `sanitizeOutputConfig` so the derived effort is normalized
+* against the model's advertised efforts.
+*/
+function convertEnabledThinkingToAdaptive(payload, model) {
+	if (payload.thinking?.type !== "enabled") return;
+	if (!modelCache.supportsAdaptiveThinking(model)) return;
+	const budget = payload.thinking.budget_tokens;
+	payload.thinking = { type: "adaptive" };
+	if (payload.output_config?.effort == null && modelCache.supportsOutputConfig(model)) payload.output_config = {
+		...payload.output_config,
+		effort: budgetTokensToEffort(budget)
+	};
+}
 function sanitizeOutputConfig(payload, model) {
 	if (!payload.output_config) return;
 	if (!modelCache.supportsOutputConfig(model)) {
@@ -49668,6 +49694,44 @@ const messagesModelChain = composeModelTransforms(rewriteStep, modelPolicyStep);
 const chatCompletionsModelChain = composeModelTransforms(rewriteStep);
 const responsesModelChain = composeModelTransforms(rewriteStep);
 //#endregion
+//#region src/translator/anthropic/document.ts
+/** Trimmed text of a `content`-source document part, or undefined when it carries none. */
+function documentPartText(part) {
+	if (part && typeof part === "object" && typeof part.text === "string") return part.text.trim() || void 0;
+}
+/** A short reference identifying a non-text document source, or '' when none is available. */
+function documentSourceRef(source) {
+	if (typeof source.url === "string") return `: ${source.url}`;
+	if (typeof source.file_id === "string") return `: ${source.file_id}`;
+	if (typeof source.media_type === "string") return `: ${source.media_type}`;
+	return "";
+}
+/**
+* Flatten an Anthropic `document` content block to plain text for translation
+* paths that cannot carry an attachment (Chat Completions, and the native
+* mixed-search-result flatten path). Text and content sources inline their
+* text; file/url/base64 sources have no text to inline, so they degrade to a
+* reference-labelled placeholder (mirroring `[image omitted: <media_type>]`)
+* rather than a content-free token. Anthropic allows `document` blocks inside
+* `tool_result.content` alongside `text`, `image`, and `search_result`.
+*/
+function formatDocumentBlock(block) {
+	const source = block.source;
+	if (source.type === "text" && typeof source.data === "string") {
+		const text = source.data.trim();
+		return text ? `[document]\n${text}` : "[document]";
+	}
+	if (source.type === "content" && Array.isArray(source.content)) {
+		const parts = [];
+		for (const part of source.content) {
+			const text = documentPartText(part);
+			if (text) parts.push(text);
+		}
+		return parts.length ? `[document]\n${parts.join("\n")}` : "[document]";
+	}
+	return `[document${documentSourceRef(source)}]`;
+}
+//#endregion
 //#region src/translator/anthropic/search-result.ts
 function formatSearchResultBlock(block) {
 	const content = block.content.map((part) => part.text.trim()).filter(Boolean).join("\n");
@@ -49711,6 +49775,7 @@ function normalizeToolResultContentValue(content) {
 			case "text": return textBlock(contentBlock.text);
 			case "image": return imageBlock(contentBlock.source.media_type, contentBlock.source.data);
 			case "search_result": return textBlock(formatSearchResultBlock(contentBlock));
+			case "document": return textBlock(formatDocumentBlock(contentBlock));
 			default: return assertNever(contentBlock);
 		}
 	});
@@ -51126,6 +51191,12 @@ function convertToolResultContent(content) {
 		case "search_result":
 			result.push(createTextContent(formatSearchResultBlock(block)));
 			break;
+		case "document": {
+			const source = block.source;
+			if (source.type === "file" || source.type === "url" || source.type === "base64") result.push(createDocumentContent(block));
+			else result.push(createTextContent(formatDocumentBlock(block)));
+			break;
+		}
 		default: break;
 	}
 	return result;
@@ -51450,6 +51521,7 @@ function stringifyToolResultContent(content) {
 			case "text": return block.text;
 			case "image": return `[image omitted: ${block.source.media_type}]`;
 			case "search_result": return formatSearchResultBlock(block);
+			case "document": return formatDocumentBlock(block);
 		}
 		return "";
 	}).filter(Boolean).join("\n\n");
@@ -52073,6 +52145,7 @@ const nativeMessagesEntry = {
 	name: "native-messages",
 	canHandle: (model, ctx) => modelCache.supportsEndpoint(model, "/v1/messages") && !hasOutputConfigFormat(ctx?.anthropicPayload),
 	async execute(ctx) {
+		convertEnabledThinkingToAdaptive(ctx.anthropicPayload, ctx.selectedModel);
 		filterThinkingBlocksForNativeMessages(ctx.anthropicPayload);
 		sanitizeOutputConfig(ctx.anthropicPayload, ctx.selectedModel);
 		sanitizeCacheControl(ctx.anthropicPayload);