@animalabs/membrane 0.5.68 → 0.5.70

package/src/providers/anthropic-tool-schema.ts

@@ -0,0 +1,194 @@
+/**
+ * Anthropic tool-schema normalization
+ *
+ * MCP permits a tool's input JSON Schema to have a root-level `oneOf` /
+ * `anyOf` / `allOf` (a union of alternative argument shapes). The Anthropic
+ * API does not: `input_schema` must be a single object-type schema, and a
+ * root-level combinator is rejected with 400
+ * ("input_schema does not support oneOf, allOf, or anyOf at the top level").
+ * One such tool 400s the entire inference — same philosophy as
+ * `normalize-tool-pairs`: repair at the wire boundary instead of letting a
+ * producer-side quirk kill the turn.
+ *
+ * `flattenRootSchemaUnion` rewrites the common case — every union variant is
+ * itself an object schema — into a single object schema:
+ *
+ *   - `properties` is the merge of all variants' properties (first wins on
+ *     key collision).
+ *   - `required`: for `allOf` (intersective — every variant applies) the
+ *     union of the variants' required lists; for `oneOf`/`anyOf`
+ *     (alternatives) only keys required by *every* variant stay required.
+ *   - A short note enumerating the alternative argument groups is appended
+ *     to the description so the model still sees the union intent.
+ *   - Variant-level `additionalProperties: false` is dropped: the merged
+ *     object is a permissive superset of the alternatives, and `false`
+ *     could reject payloads valid under one of the original variants.
+ *
+ * If any variant is not object-shaped (e.g. a root `oneOf` of a string and
+ * an object), the union cannot be merged into properties; we fall back to a
+ * permissive object schema carrying the serialized union in the description.
+ * Degenerate, but it does not 400 — the tool stays callable and the model
+ * sees the accepted shapes.
+ *
+ * Nested combinators (inside `properties`, array `items`, etc.) are legal
+ * for Anthropic and are left untouched; only the root is rewritten.
+ */
+
+function isPlainObject(value: unknown): value is Record<string, unknown> {
+  return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+
+function isMergeableObjectVariant(variant: Record<string, unknown>): boolean {
+  return (
+    variant.type === 'object' ||
+    (variant.type === undefined && isPlainObject(variant.properties))
+  );
+}
+
+function stringRequired(value: unknown): string[] {
+  return Array.isArray(value)
+    ? value.filter((entry): entry is string => typeof entry === 'string')
+    : [];
+}
+
+const ROOT_UNION_KEYS = ['oneOf', 'anyOf', 'allOf'] as const;
+
+/** Max length of the description we synthesize on the fallback path. */
+const MAX_FALLBACK_DESCRIPTION = 4000;
+
+/**
+ * Rewrite a root-level `oneOf`/`anyOf`/`allOf` in a tool input schema into a
+ * single Anthropic-acceptable object schema. Returns the input unchanged
+ * (same reference) when there is nothing to repair, so callers can cheaply
+ * detect whether a rewrite happened.
+ */
+export function flattenRootSchemaUnion(schema: unknown): unknown {
+  if (!isPlainObject(schema)) return schema;
+
+  // A root may carry more than one combinator at once (e.g. `{ oneOf, anyOf }`).
+  // These are sibling keywords: a valid instance must satisfy every one of
+  // them (an implicit `allOf` across the combinators). Process *all* present
+  // keys — handling only the first would strip the others' variants (the
+  // destructuring below removes all three keys), silently losing their
+  // properties and required lists.
+  const presentKeys = ROOT_UNION_KEYS.filter(
+    (key) => Array.isArray(schema[key]) && (schema[key] as unknown[]).length > 0,
+  );
+  if (presentKeys.length === 0) return schema;
+
+  const combinators = presentKeys.map((key) => {
+    const raw = schema[key] as unknown[];
+    return { key, raw, variants: raw.filter(isPlainObject) };
+  });
+  const rawVariantsAll: unknown[] = combinators.flatMap(({ raw }) => raw);
+
+  // Keep every root key except the combinators themselves.
+  const { oneOf: _oneOf, anyOf: _anyOf, allOf: _allOf, ...rest } = schema;
+
+  const allMergeable = combinators.every(
+    ({ raw, variants }) =>
+      variants.length === raw.length && variants.every(isMergeableObjectVariant),
+  );
+
+  if (allMergeable) {
+    // Common case: every variant of every present combinator is an object
+    // schema — merge them all.
+    const properties: Record<string, unknown> = isPlainObject(rest.properties)
+      ? { ...rest.properties }
+      : {};
+    for (const { variants } of combinators) {
+      for (const variant of variants) {
+        if (isPlainObject(variant.properties)) {
+          for (const [key, propSchema] of Object.entries(variant.properties)) {
+            if (!(key in properties)) properties[key] = propSchema;
+          }
+        }
+      }
+    }
+
+    // Per-combinator required semantics: `allOf` unions its variants' required
+    // lists (every variant applies); `oneOf`/`anyOf` keep only keys required by
+    // every variant (alternatives). Across combinators they all apply at once,
+    // so the effective required set is the union of the per-combinator results.
+    const mergedRequired = combinators.flatMap(({ key, variants }) => {
+      const variantRequired = variants.map((variant) => stringRequired(variant.required));
+      return key === 'allOf'
+        ? [...new Set(variantRequired.flat())]
+        : variantRequired.reduce(
+            (acc, req) => acc.filter((k) => req.includes(k)),
+            variantRequired[0] ?? [],
+          );
+    });
+    const required = [
+      ...new Set([...stringRequired(rest.required), ...mergedRequired]),
+    ].filter((key) => key in properties);
+
+    const {
+      properties: _properties,
+      required: _required,
+      additionalProperties: _additionalProperties,
+      ...restSansObjectKeys
+    } = rest;
+
+    const result: Record<string, unknown> = {
+      ...restSansObjectKeys,
+      type: 'object',
+      properties,
+    };
+    if (required.length > 0) result.required = required;
+
+    // For alternatives, preserve the union intent in prose so the model
+    // still knows the arguments come in groups (one line per combinator).
+    const noteParts = combinators
+      .filter(({ key, variants }) => key !== 'allOf' && variants.length > 1)
+      .map(({ variants }) => {
+        const groups = variants
+          .map((variant) => {
+            const req = stringRequired(variant.required);
+            return req.length > 0 ? `(${req.join(', ')})` : '(no required fields)';
+          })
+          .join(' | ');
+        return `Provide one of the following argument groups: ${groups}.`;
+      });
+    if (noteParts.length > 0) {
+      const note = noteParts.join('\n');
+      result.description =
+        typeof result.description === 'string' && result.description.length > 0
+          ? `${result.description}\n${note}`
+          : note;
+    }
+
+    return result;
+  }
+
+  // Fallback: at least one variant (across the present combinators) is not an
+  // object schema (or not a schema at all). Emit a permissive object schema and
+  // carry the union(s) into the description so the intent survives.
+  const label = presentKeys.join('/');
+  let note: string;
+  try {
+    note = `Accepts one of the following input shapes (flattened from a root-level ${label}): ${JSON.stringify(rawVariantsAll)}`;
+  } catch {
+    note = `Accepts one of ${rawVariantsAll.length} alternative input shapes (root-level ${label} flattened).`;
+  }
+  const baseDescription =
+    typeof rest.description === 'string' && rest.description.length > 0
+      ? `${rest.description}\n${note}`
+      : note;
+
+  // Spread `rest` (already sans the combinator keys) so sibling definitions —
+  // `$defs`/`definitions` — survive. Without this, a variant serialized into
+  // the description as `{"$ref":"#/definitions/A"}` would point at a definition
+  // that no longer exists anywhere in the tool. The mergeable path preserves
+  // `restSansObjectKeys` for the same reason; the fallback extends the courtesy.
+  return {
+    ...rest,
+    type: 'object',
+    properties: isPlainObject(rest.properties) ? rest.properties : {},
+    additionalProperties: true,
+    description:
+      baseDescription.length > MAX_FALLBACK_DESCRIPTION
+        ? baseDescription.slice(0, MAX_FALLBACK_DESCRIPTION)
+        : baseDescription,
+  };
+}

package/src/providers/anthropic.ts

@@ -3,6 +3,7 @@
  */
 
 import Anthropic, { type ClientOptions } from '@anthropic-ai/sdk';
+import { assertWithinByteBudget, shedImagesToFitByteBudget } from '../utils/image-media.js';
 import type {
   ProviderAdapter,
   ProviderRequest,
@@ -20,6 +21,52 @@ import {
   serverError,
   abortError,
 } from '../types/index.js';
+import { flattenRootSchemaUnion } from './anthropic-tool-schema.js';
+
+// ============================================================================
+// Model capability gates
+// ============================================================================
+
+/**
+ * Models that reject the sampling parameters (`temperature`, `top_p`,
+ * `top_k`) with a 400 invalid_request_error — which Membrane classifies as
+ * non-retryable, so a single stray `temperature` kills the whole turn.
+ * Mirrors the `noTemperatureSupport` gate in the OpenAI provider.
+ *
+ * This is the always-on-thinking / reasoning-forward tier, which removes the
+ * sampling parameters from the API surface entirely (Sonnet 5 rejects only
+ * non-default values). Everything else — Haiku 4.5, Sonnet 4.6, Opus 4.6 and
+ * older — ACCEPTS `temperature`, so it must NOT be listed here.
+ *
+ *   - Opus 4.7 / Opus 4.8 / Sonnet 5 / Fable 5 / Mythos 5 / Mythos preview:
+ *     documented 400 on any sampling parameter.
+ *
+ * NB: claude-haiku-4-5 was previously listed here on the strength of a single
+ * "observed 400 in production when temperature is sent" anecdote. Haiku 4.5
+ * documentably supports `temperature`; the production 400 was almost certainly
+ * the `extra`-params bypass fixed in this same PR (a sampling param smuggled
+ * through `extra` and re-inserted after the gate — 400s on any model), not a
+ * capability of Haiku. Listing it silently discarded a valid parameter on the
+ * most common cheap model, so it has been removed.
+ *
+ * Prefix-matched, so dated snapshots (e.g. claude-opus-4-8-20251001) are
+ * covered. Keep this list updated as models launch.
+ */
+const NO_TEMPERATURE_MODELS = [
+  'claude-opus-4-7',
+  'claude-opus-4-8',
+  'claude-sonnet-5',
+  'claude-fable-5',
+  'claude-mythos-5',
+  'claude-mythos-preview',
+];
+
+/**
+ * Check if a model doesn't support custom sampling parameters
+ */
+function noTemperatureSupport(model: string): boolean {
+  return NO_TEMPERATURE_MODELS.some(prefix => model.startsWith(prefix));
+}
 
 // ============================================================================
 // Adapter Configuration
@@ -139,6 +186,11 @@ export class AnthropicAdapter implements ProviderAdapter {
       let outputTokens = 0;
       let cacheCreationTokens: number | undefined;
       let cacheReadTokens: number | undefined;
+      let cacheCreation5mTokens: number | undefined;
+      let cacheCreation1hTokens: number | undefined;
+      let hasCacheCreationBreakdown = false;
+      let inferenceGeo: string | undefined;
+      let serviceTier: string | undefined;
       let stopReason: string = 'end_turn';
       let stopSequence: string | undefined;
       let stopDetails: unknown;
@@ -160,10 +212,22 @@ export class AnthropicAdapter implements ProviderAdapter {
         resetIdleTimer();
         if (event.type === 'message_start') {
           model = event.message.model;
-          const usage = event.message.usage as unknown as Record<string, number>;
-          inputTokens = usage.input_tokens ?? 0;
-          cacheCreationTokens = usage.cache_creation_input_tokens;
-          cacheReadTokens = usage.cache_read_input_tokens;
+          const usage = event.message.usage as unknown as Record<string, unknown>;
+          inputTokens = typeof usage.input_tokens === 'number' ? usage.input_tokens : 0;
+          cacheCreationTokens = typeof usage.cache_creation_input_tokens === 'number'
+            ? usage.cache_creation_input_tokens : undefined;
+          cacheReadTokens = typeof usage.cache_read_input_tokens === 'number'
+            ? usage.cache_read_input_tokens : undefined;
+          const cacheCreation = usage.cache_creation as Record<string, unknown> | undefined;
+          if (cacheCreation) {
+            hasCacheCreationBreakdown = true;
+            cacheCreation5mTokens = typeof cacheCreation.ephemeral_5m_input_tokens === 'number'
+              ? cacheCreation.ephemeral_5m_input_tokens : 0;
+            cacheCreation1hTokens = typeof cacheCreation.ephemeral_1h_input_tokens === 'number'
+              ? cacheCreation.ephemeral_1h_input_tokens : 0;
+          }
+          inferenceGeo = typeof usage.inference_geo === 'string' ? usage.inference_geo : undefined;
+          serviceTier = typeof usage.service_tier === 'string' ? usage.service_tier : undefined;
 
         } else if (event.type === 'content_block_start') {
           currentBlockIndex = event.index;
@@ -277,6 +341,14 @@ export class AnthropicAdapter implements ProviderAdapter {
             output_tokens: outputTokens,
             cache_creation_input_tokens: cacheCreationTokens,
             cache_read_input_tokens: cacheReadTokens,
+            ...(hasCacheCreationBreakdown ? {
+              cache_creation: {
+                ephemeral_5m_input_tokens: cacheCreation5mTokens ?? 0,
+                ephemeral_1h_input_tokens: cacheCreation1hTokens ?? 0,
+              },
+            } : {}),
+            ...(inferenceGeo ? { inference_geo: inferenceGeo } : {}),
+            ...(serviceTier ? { service_tier: serviceTier } : {}),
           },
         },
       };
@@ -326,6 +398,13 @@ export class AnthropicAdapter implements ProviderAdapter {
       };
     });
 
+    // Byte-wall INVARIANT at the last exit before the SDK (2026-07-12): the
+    // policy decision (shed with explicit opt-in, or fail loudly) happens
+    // upstream at the request-build sites. Reaching this point oversize means
+    // a compile path bypassed the policy — throw with the breakdown rather
+    // than silently mutate or eat a 413 round-trip.
+    assertWithinByteBudget(sanitizedMessages, undefined, 'anthropic-provider');
+
     const params: Anthropic.MessageCreateParams = {
       model: request.model,
       max_tokens: request.maxTokens || this.defaultMaxTokens,
@@ -342,17 +421,42 @@ export class AnthropicAdapter implements ProviderAdapter {
       }
     }
     
-    if (request.temperature !== undefined) {
+    // Sampling-parameter gates:
+    //   - Some models reject temperature/top_p/top_k outright with a 400
+    //     (see NO_TEMPERATURE_MODELS) — strip rather than let the whole
+    //     inference die on a non-retryable invalid_request_error.
+    //   - Extended thinking rejects custom temperature/top_k on every model
+    //     (only the defaults are accepted while thinking is on) — strip those
+    //     too when a thinking config is present and not disabled.
+    const stripSampling = noTemperatureSupport(request.model);
+    // Thinking can arrive top-level OR smuggled through `extra` — the same
+    // `Object.assign(params, rest)` below installs `extra.thinking` into the
+    // request AFTER this gate ran. Resolve from both sources so an enabled
+    // thinking config strips sampling params no matter where it came from;
+    // otherwise `extra: { thinking, temperature }` reproduces the exact 400
+    // this gate exists to prevent (same bug class as the extra-sampling bypass,
+    // one field over).
+    const extraThinking = (request.extra as { thinking?: { type?: string } } | undefined)?.thinking;
+    const thinkingConfig = request.thinking ?? extraThinking;
+    const thinkingOn = thinkingConfig !== undefined && thinkingConfig.type !== 'disabled';
+
+    if (request.temperature !== undefined && !stripSampling && !thinkingOn) {
       params.temperature = request.temperature;
     }
 
     // Anthropic API rejects requests with both temperature and top_p set.
     // When both are provided, prefer temperature (more commonly tuned) and drop top_p.
-    if (request.topP !== undefined && request.temperature === undefined) {
+    // With thinking on, top_p is only accepted in [0.95, 1] — strip values below.
+    if (
+      request.topP !== undefined &&
+      params.temperature === undefined &&
+      !stripSampling &&
+      (!thinkingOn || request.topP >= 0.95)
+    ) {
       params.top_p = request.topP;
     }
 
-    if (request.topK !== undefined) {
+    if (request.topK !== undefined && !stripSampling && !thinkingOn) {
       params.top_k = request.topK;
     }
 
@@ -361,17 +465,43 @@ export class AnthropicAdapter implements ProviderAdapter {
     }
     
     if (request.tools && request.tools.length > 0) {
-      params.tools = request.tools as Anthropic.Tool[];
+      // MCP allows a root-level oneOf/anyOf/allOf in a tool's input schema,
+      // but the Anthropic API rejects it ("input_schema does not support
+      // oneOf, allOf, or anyOf at the top level") — one bad tool 400s the
+      // entire inference. Flatten such roots into a single object schema
+      // before shipping (see anthropic-tool-schema.ts).
+      params.tools = (request.tools as Anthropic.Tool[]).map(tool => {
+        const inputSchema = (tool as { input_schema?: unknown }).input_schema;
+        const flattened = flattenRootSchemaUnion(inputSchema);
+        return flattened === inputSchema
+          ? tool
+          : ({ ...tool, input_schema: flattened } as Anthropic.Tool);
+      });
     }
 
     // Handle extended thinking
-    if ((request as any).thinking) {
-      (params as any).thinking = (request as any).thinking;
+    if (request.thinking) {
+      (params as any).thinking = request.thinking;
     }
 
     // Apply extra params, excluding internal membrane fields
     if (request.extra) {
       const { normalizedMessages, prompt, ...rest } = request.extra as Record<string, unknown>;
+      // Sampling params passed through `extra` must obey the same gates as the
+      // top-level ones. Otherwise a caller passing e.g. `extra: { temperature }`
+      // for a reject-list model (or under extended thinking) would re-insert the
+      // stripped value here — via Object.assign, after the gate above — and
+      // reproduce the exact non-retryable 400 this stripping is meant to prevent.
+      if (stripSampling || thinkingOn) {
+        delete rest.temperature;
+        delete rest.top_k;
+        // top_p is accepted in [0.95, 1] while thinking is on, but never when
+        // the model rejects sampling params outright.
+        const extraTopP = rest.top_p;
+        if (stripSampling || typeof extraTopP !== 'number' || extraTopP < 0.95) {
+          delete rest.top_p;
+        }
+      }
       Object.assign(params, rest);
     }
 

package/src/providers/gemini.ts

@@ -428,6 +428,20 @@ export class GeminiAdapter implements ProviderAdapter {
                 },
               });
             }
+          } else if (block.type === 'audio') {
+            // Audio input → Gemini inlineData (same mechanism as images). This is
+            // pure plumbing: whether a given model accepts/understands audio is the
+            // model's concern (the caller decides what to send). Common MIME types:
+            // audio/mp3, audio/wav, audio/ogg, audio/flac.
+            const source = block.source;
+            if (source?.type === 'base64' && source.data) {
+              parts.push({
+                inlineData: {
+                  mimeType: source.mediaType ?? source.media_type ?? 'audio/mpeg',
+                  data: source.data,
+                },
+              });
+            }
           } else if (block.type === 'tool_use') {
             parts.push({
               functionCall: {

package/src/providers/index.ts

@@ -9,6 +9,8 @@ export {
   type AnthropicAdapterConfig,
 } from './anthropic.js';
 
+export { flattenRootSchemaUnion } from './anthropic-tool-schema.js';
+
 export {
   OpenRouterAdapter,
   toOpenRouterMessages,
@@ -58,3 +60,14 @@ export {
   OpenAIResponsesAdapter,
   type OpenAIResponsesAdapterConfig,
 } from './openai-responses.js';
+
+export {
+  OpenAIResponsesAPIAdapter,
+  type OpenAIResponsesAPIAdapterConfig,
+  type OpenAIResponsesAPIContentBlock,
+  type OpenAIResponsesAPIProviderResponse,
+  type OpenAIResponsesAPIRequest,
+  type OpenAIResponsesAPIResponse,
+  type OpenAIResponsesInputItem,
+  type OpenAIResponsesOutputItem,
+} from './openai-responses-api.js';