@genesislcap/foundation-ai 15.14.2 → 15.15.0

package/dist/esm/transports/anthropic-transport.js

@@ -1,5 +1,6 @@
 import { __awaiter } from "tslib";
 import { SUPPORTED_ANTHROPIC_MODEL_IDS, } from '../types';
+import { normalizeImageMime, stripImageDataUrl } from '../utils/image-mime';
 import { logger } from '../utils/logger';
 import { scaleTemperature } from '../utils/temperature';
 import { anthropicTokenCost } from '../utils/token-cost';
@@ -136,9 +137,58 @@ function anthropicThinking(model, policy) {
     if (policy === 'auto') {
         return supportsAdaptiveThinking(model) ? adaptive : undefined;
     }
+    // A graded level asks for reasoning DEPTH, which on Anthropic is `output_config.effort`
+    // riding alongside adaptive thinking (see `anthropicEffort`). Asking for a depth on a model
+    // with no adaptive support leaves it at its default rather than 400ing the turn.
+    if (policy !== undefined) {
+        return supportsAdaptiveThinking(model) ? adaptive : undefined;
+    }
     // policy === undefined → the per-model default, unchanged.
     return defaultsToThinking ? adaptive : undefined;
 }
+/**
+ * Whether the model accepts `output_config.effort`.
+ *
+ * An allow-list, and deliberately the same generation {@link supportsNativeStructuredOutput}
+ * treats as new, minus Haiku: `effort` and `format` share the one `output_config` container, so
+ * the two gates must agree on which models understand it. `output_config` arrived with the
+ * Fable 5 / Opus 4.8 / Sonnet 5 generation — Opus 4.7 and Sonnet 4.6 predate it and 400 on a
+ * field inside it, so a graded policy is dropped for them (they run their default posture, with a
+ * one-time warning from {@link AnthropicTransport}) rather than forwarded into a failed turn.
+ *
+ * Haiku 4.5 is the lone asymmetry with `supportsNativeStructuredOutput`, which lists it: Haiku
+ * took `output_config.format` but not `.effort`, and has no adaptive thinking for effort to ride
+ * on anyway (`anthropicEffort` also gates on {@link supportsAdaptiveThinking}). An allow-list is
+ * the safe default for a "send-it-and-400" parameter — a newly added model gets no `effort` until
+ * it is confirmed to accept it.
+ */
+function supportsEffort(model) {
+    return model === 'claude-fable-5' || model === 'claude-opus-4-8' || model === 'claude-sonnet-5';
+}
+/**
+ * `output_config.effort` for a graded policy.
+ *
+ * An exhaustive `Record`, not a condition chain: adding a member to {@link ChatThinkingLevel}
+ * then fails to compile here instead of silently falling through to the model default, which is
+ * the failure mode this mapping is most likely to acquire.
+ *
+ * `'minimal'` clamps UP to `low` — Anthropic's ladder starts there. `xhigh` is deliberately
+ * unreachable; see {@link ChatThinkingPolicy}.
+ */
+const ANTHROPIC_EFFORT = {
+    minimal: 'low',
+    low: 'low',
+    medium: 'medium',
+    high: 'high',
+    max: 'max',
+};
+function anthropicEffort(model, policy) {
+    if (policy === undefined || policy === 'auto' || policy === 'off')
+        return undefined;
+    if (!supportsEffort(model) || !supportsAdaptiveThinking(model))
+        return undefined;
+    return ANTHROPIC_EFFORT[policy];
+}
 /**
  * Key under which this transport stashes its round-trip state on a tool call's
  * provider-neutral `providerMetadata` bag. Private to AnthropicTransport.
@@ -213,14 +263,48 @@ export class AnthropicTransport {
     warnIfThinkingUnclampable(policy) {
         if (this.warnedThinkingClamped)
             return;
-        const clamped = (policy === 'off' && thinkingIsMandatory(this.model)) ||
-            (policy === 'auto' && !supportsAdaptiveThinking(this.model));
-        if (!clamped)
+        const message = this.clampWarning(policy);
+        if (!message)
             return;
         this.warnedThinkingClamped = true;
-        logger.warn(policy === 'off'
-            ? `AnthropicTransport: thinkingPolicy 'off' ignored — ${this.model} always thinks and rejects an explicit disable. Reasoning tokens are still billed as output; switch model if you need them gone.`
-            : `AnthropicTransport: thinkingPolicy 'auto' ignored — ${this.model} does not support adaptive thinking, so this turn runs without reasoning. Use a Sonnet or Opus tier if the agent needs it.`);
+        logger.warn(message);
+    }
+    /**
+     * The warning for a policy this model cannot honour, or `undefined` when it can.
+     *
+     * An exhaustive `switch` with a `never` check rather than a condition chain: a new
+     * {@link ChatThinkingPolicy} member must be considered HERE or the build fails. The condition
+     * chain this replaced would have let every graded level clamp in silence, which is the one
+     * outcome the type's own docs promise callers never happens.
+     */
+    clampWarning(policy) {
+        switch (policy) {
+            case undefined:
+                return undefined;
+            case 'off':
+                return thinkingIsMandatory(this.model)
+                    ? `AnthropicTransport: thinkingPolicy 'off' ignored — ${this.model} always thinks and rejects an explicit disable. Reasoning tokens are still billed as output; switch model if you need them gone.`
+                    : undefined;
+            case 'auto':
+                return supportsAdaptiveThinking(this.model)
+                    ? undefined
+                    : `AnthropicTransport: thinkingPolicy 'auto' ignored — ${this.model} does not support adaptive thinking, so this turn runs without reasoning. Use a Sonnet or Opus tier if the agent needs it.`;
+            case 'minimal':
+            case 'low':
+            case 'medium':
+            case 'high':
+            case 'max':
+                if (!supportsAdaptiveThinking(this.model) || !supportsEffort(this.model)) {
+                    return `AnthropicTransport: thinkingPolicy '${policy}' ignored — ${this.model} predates output_config.effort, so this turn runs at its default posture. Use Opus 4.8, Sonnet 5, or Fable 5 to set reasoning depth.`;
+                }
+                // A clamp WITHIN the supported ladder is documented on the type (Anthropic has no
+                // 'minimal'), costs nothing, and would be noise on every turn of a vision loop.
+                return undefined;
+            default: {
+                const exhaustive = policy;
+                return exhaustive;
+            }
+        }
     }
     constructor(config = {}) {
         var _a, _b, _c, _d;
@@ -308,9 +392,7 @@ export class AnthropicTransport {
             const useNative = responseSchema != null && supportsNativeStructuredOutput(this.model);
             const useForcedTool = responseSchema != null && !useNative;
             if (useNative) {
-                body.output_config = {
-                    format: { type: 'json_schema', schema: responseSchema },
-                };
+                body.output_config = Object.assign(Object.assign({}, body.output_config), { format: { type: 'json_schema', schema: responseSchema } });
             }
             else if (useForcedTool) {
                 body.tools = [
@@ -344,7 +426,7 @@ export class AnthropicTransport {
     // ── ChatTransport (multi-turn chat) ────────────────────────────────────
     sendChatMessage(history, userMessage, options) {
         return __awaiter(this, void 0, void 0, function* () {
-            var _a, _b, _c, _d;
+            var _a, _b, _c, _d, _e;
             // The models this request could actually be served by — the configured one plus any
             // fallback target. Needed when replaying reasoning: a signature is only valid for the
             // model that produced it, so stored blocks are replayed only when their producer is
@@ -356,12 +438,13 @@ export class AnthropicTransport {
             const messages = this.toAnthropicMessages(history, userMessage, options === null || options === void 0 ? void 0 : options.attachments, reachableModels);
             const body = {
                 model: this.model,
-                max_tokens: this.maxTokens,
+                // Per-turn override wins over the instance default; see ChatRequestOptions.maxTokens.
+                max_tokens: (_b = options === null || options === void 0 ? void 0 : options.maxTokens) !== null && _b !== void 0 ? _b : this.maxTokens,
                 messages,
             };
             if (options === null || options === void 0 ? void 0 : options.systemPrompt)
                 body.system = options.systemPrompt;
-            if ((_b = options === null || options === void 0 ? void 0 : options.tools) === null || _b === void 0 ? void 0 : _b.length) {
+            if ((_c = options === null || options === void 0 ? void 0 : options.tools) === null || _c === void 0 ? void 0 : _c.length) {
                 // `enforceSchema` is a per-tool opt-in, and the provider compiles per tool:
                 // an unenforced tool is never compiled and costs nothing against the
                 // compilation limits, so marking one tool in a large surface is legitimate.
@@ -375,7 +458,7 @@ export class AnthropicTransport {
             // Map the requested tool-call mode to Anthropic's tool_choice — only
             // meaningful when tools exist. `'required'`/`{ tool }` force a tool call so
             // a turn can only end via one (e.g. a sub-agent's completion tool).
-            if ((_c = body.tools) === null || _c === void 0 ? void 0 : _c.length) {
+            if ((_d = body.tools) === null || _d === void 0 ? void 0 : _d.length) {
                 const toolChoice = toAnthropicToolChoice(options === null || options === void 0 ? void 0 : options.toolChoice);
                 if (toolChoice)
                     body.tool_choice = toolChoice;
@@ -388,6 +471,13 @@ export class AnthropicTransport {
             const thinking = anthropicThinking(this.model, options === null || options === void 0 ? void 0 : options.thinkingPolicy);
             if (thinking)
                 body.thinking = thinking;
+            // Reasoning DEPTH rides in `output_config.effort`, a different field from `thinking`.
+            // MERGED, never assigned: structured output writes `format` into the same object further
+            // down, and either write clobbering the other is silent — the request stays valid, it just
+            // quietly stops doing one of the two things it was asked to do.
+            const effort = anthropicEffort(this.model, options === null || options === void 0 ? void 0 : options.thinkingPolicy);
+            if (effort)
+                body.output_config = Object.assign(Object.assign({}, body.output_config), { effort });
             // Normalized [0,1] temperature → Anthropic's native range, anchored so 0.5 maps to its default.
             // (Default == max here, so the upper half is flat.) Skipped in two cases:
             //
@@ -411,14 +501,12 @@ export class AnthropicTransport {
             // models that support it natively; elsewhere the schema is dropped here (the caller keeps a
             // prompt-instruction + validator fallback). No beta header needed.
             if ((options === null || options === void 0 ? void 0 : options.responseSchema) && supportsNativeStructuredOutput(this.model)) {
-                body.output_config = {
-                    format: { type: 'json_schema', schema: options.responseSchema },
-                };
+                body.output_config = Object.assign(Object.assign({}, body.output_config), { format: { type: 'json_schema', schema: options.responseSchema } });
             }
             // Refusal fallback chain (e.g. Fable 5 → Opus 4.8). Sent as the server-side `fallbacks`
             // param; `post` adds the required beta header when this is present. A refused turn is
             // re-run on the next model in one round trip.
-            if ((_d = options === null || options === void 0 ? void 0 : options.fallbacks) === null || _d === void 0 ? void 0 : _d.length) {
+            if ((_e = options === null || options === void 0 ? void 0 : options.fallbacks) === null || _e === void 0 ? void 0 : _e.length) {
                 body.fallbacks = options.fallbacks.map((f) => f.maxTokens != null ? { model: f.model, max_tokens: f.maxTokens } : { model: f.model });
             }
             // Place prompt-cache breakpoints per the resolved policy (no-op for `'default'`/absent).
@@ -431,7 +519,7 @@ export class AnthropicTransport {
                 this.appendTailContext(body, options.tailContext);
             }
             const response = yield this.post(body, options === null || options === void 0 ? void 0 : options.signal);
-            return this.fromAnthropicResponse(response);
+            return this.fromAnthropicResponse(response, body.max_tokens);
         });
     }
     /**
@@ -533,7 +621,7 @@ export class AnthropicTransport {
      * the payload tidy.
      */
     toAnthropicMessages(history, userMessage, attachments, reachableModels = new Set([this.model])) {
-        var _a, _b, _c;
+        var _a, _b, _c, _d;
         const messages = [];
         const pushBlock = (role, block) => {
             const last = messages[messages.length - 1];
@@ -543,6 +631,33 @@ export class AnthropicTransport {
             }
             messages.push({ role, content: [block] });
         };
+        /**
+         * Split attachments by kind. Images are emitted BEFORE the accompanying text (the order
+         * Anthropic's vision guidance specifies); text attachments keep their existing position
+         * AFTER it, so a turn with no images produces a byte-identical request to before.
+         *
+         * Branches on `kind`, never on `mimeType` — see {@link ChatImageAttachment}.
+         */
+        const splitAttachments = (atts) => {
+            const images = [];
+            const texts = [];
+            for (const att of atts) {
+                if (att.kind === 'image') {
+                    images.push({
+                        type: 'image',
+                        source: {
+                            type: 'base64',
+                            media_type: normalizeImageMime(att.mimeType),
+                            data: stripImageDataUrl(att.data),
+                        },
+                    });
+                }
+                else {
+                    texts.push({ type: 'text', text: `[File: ${att.name}]\n${att.content}` });
+                }
+            }
+            return { images, texts };
+        };
         for (const msg of history) {
             if (msg.role === 'system' ||
                 msg.role === 'system-event' ||
@@ -554,14 +669,34 @@ export class AnthropicTransport {
             )
                 continue;
             if (msg.toolResult) {
+                const resultImages = (_a = msg.toolResult.attachments) !== null && _a !== void 0 ? _a : [];
                 pushBlock('user', {
                     type: 'tool_result',
                     tool_use_id: msg.toolResult.toolCallId,
-                    content: msg.toolResult.content,
+                    // Bare string when there are no images — the historical shape, byte for byte.
+                    content: resultImages.length
+                        ? [
+                            // Text block only when there IS text. A handler can return an image with no
+                            // caption (`{ content: '', attachments: [img] }` — the mainline vision-agent
+                            // "just look at this" shape), and Anthropic 400s an empty text block, live and on
+                            // replay. Guarded like every user-turn path; the array is then image-only.
+                            ...(msg.toolResult.content
+                                ? [{ type: 'text', text: msg.toolResult.content }]
+                                : []),
+                            ...resultImages.map((att) => ({
+                                type: 'image',
+                                source: {
+                                    type: 'base64',
+                                    media_type: normalizeImageMime(att.mimeType),
+                                    data: stripImageDataUrl(att.data),
+                                },
+                            })),
+                        ]
+                        : msg.toolResult.content,
                 });
                 continue;
             }
-            if ((_a = msg.toolCalls) === null || _a === void 0 ? void 0 : _a.length) {
+            if ((_b = msg.toolCalls) === null || _b === void 0 ? void 0 : _b.length) {
                 // Reasoning first, then text, then the calls — the order the model produced them,
                 // which is the order the API validates. A tool-use loop is one assistant turn, so
                 // resuming it requires the thinking that led to the call to still be present and
@@ -578,29 +713,38 @@ export class AnthropicTransport {
                         type: 'tool_use',
                         id: tc.id,
                         name: tc.name,
-                        input: (_b = tc.args) !== null && _b !== void 0 ? _b : {},
+                        input: (_c = tc.args) !== null && _c !== void 0 ? _c : {},
                     });
                 }
                 continue;
             }
             const role = msg.role === 'user' ? 'user' : 'assistant';
-            if (role === 'user' && ((_c = msg.attachments) === null || _c === void 0 ? void 0 : _c.length)) {
-                pushBlock(role, { type: 'text', text: msg.content });
-                for (const att of msg.attachments) {
-                    pushBlock(role, { type: 'text', text: `[File: ${att.name}]\n${att.content}` });
-                }
+            if (role === 'user' && ((_d = msg.attachments) === null || _d === void 0 ? void 0 : _d.length)) {
+                const { images, texts } = splitAttachments(msg.attachments);
+                for (const image of images)
+                    pushBlock(role, image);
+                // Guarded like the live turn below: an image-only message has empty `content`, and
+                // Anthropic 400s an empty text block. Unguarded, such a turn succeeded when sent and
+                // then failed on REPLAY — the nastiest shape of this bug, and "image, no caption" is
+                // mainline input for a vision agent.
+                if (msg.content)
+                    pushBlock(role, { type: 'text', text: msg.content });
+                for (const text of texts)
+                    pushBlock(role, text);
             }
             else if (msg.content) {
                 pushBlock(role, { type: 'text', text: msg.content });
             }
         }
         if (userMessage || (attachments === null || attachments === void 0 ? void 0 : attachments.length)) {
+            const { images, texts } = splitAttachments(attachments !== null && attachments !== void 0 ? attachments : []);
+            for (const image of images)
+                pushBlock('user', image);
             if (userMessage) {
                 pushBlock('user', { type: 'text', text: userMessage });
             }
-            for (const att of attachments !== null && attachments !== void 0 ? attachments : []) {
-                pushBlock('user', { type: 'text', text: `[File: ${att.name}]\n${att.content}` });
-            }
+            for (const text of texts)
+                pushBlock('user', text);
         }
         return messages;
     }
@@ -716,7 +860,9 @@ export class AnthropicTransport {
         const cacheCreation = (_c = usage.cache_creation_input_tokens) !== null && _c !== void 0 ? _c : (breakdown ? ((_d = breakdown.ephemeral_5m_input_tokens) !== null && _d !== void 0 ? _d : 0) + cacheCreation1h : 0);
         return this.logTokenUsage(model, (_e = usage.input_tokens) !== null && _e !== void 0 ? _e : 0, (_f = usage.output_tokens) !== null && _f !== void 0 ? _f : 0, cacheRead, cacheCreation, cacheCreation1h);
     }
-    fromAnthropicResponse(response) {
+    fromAnthropicResponse(response, 
+    /** The cap ACTUALLY sent this turn — a per-turn `maxTokens` overrides the instance one. */
+    effectiveMaxTokens = this.maxTokens) {
         var _a, _b, _c, _d, _e, _f, _g;
         let inputTokens;
         let outputTokens;
@@ -844,7 +990,7 @@ export class AnthropicTransport {
         // missing args and get retried into the same wall). Usage/cost is already
         // logged above, so the spent tokens are still accounted for on this instance.
         if (response.stop_reason === 'max_tokens' && toolCalls.length > 0) {
-            throw new ResponseTruncatedError(this.model, this.maxTokens, outputTokens, toolCalls.map((tc) => tc.name));
+            throw new ResponseTruncatedError(this.model, effectiveMaxTokens, outputTokens, toolCalls.map((tc) => tc.name));
         }
         // Reasoning (extended-thinking summary) and answer/narration travel in separate channels:
         // `content` is the answer text, `reasoning` is the summary. The driver splits them into