mixdog 1.0.9 → 1.0.11

package/src/runtime/agent/orchestrator/providers/anthropic-oauth.mjs

@@ -78,9 +78,8 @@ const _oauthRefreshes = new Map();
 // This picks up cross-process refresh_token rotation rather than replaying
 // a stale single-use token.
 
-// Anthropic OAuth contract for first-party OAuth clients: Opus/Sonnet
-// requests are gated on this exact system-prompt prefix. Haiku is not
-// gated and ignores this prefix.
+// Anthropic OAuth contract for first-party OAuth clients: Claude requests
+// are gated on this exact system-prompt prefix (Haiku 5.5 included).
 const CLAUDE_CODE_SYSTEM_PREFIX = "You are Claude Code, Anthropic's official CLI for Claude.";
 const OAUTH_BETA_HEADERS =
   'oauth-2025-04-20,interleaved-thinking-2025-05-14,context-management-2025-06-27,extended-cache-ttl-2025-04-11';
@@ -90,11 +89,9 @@ function logQuiet(line) {
 }
 
 function requiresSystemPrefix(model) {
-  // High-tier Claude OAuth models require the first-party system prefix for
-  // OAuth pool routing. Haiku does not; keep every other Claude family (Opus,
-  // Sonnet, Fable, and future non-Haiku families) on the prefixed path.
-  const id = String(model || '').toLowerCase();
-  return /^claude-/.test(id) && !/^claude-haiku(?:-|$)/.test(id);
+  // Every Claude OAuth model needs the first-party system prefix for OAuth
+  // pool routing; without it the server answers 429 rate_limit_error "Error".
+  return /^claude-/.test(String(model || '').toLowerCase());
 }
 
 function buildOAuthBetaHeaders(body, { fastMode = false, toolSearch = false, model, opts = {} } = {}) {
@@ -272,6 +269,8 @@ export function _buildRequestBodyForCacheSmoke(messages, model, tools = [], send
 // --- Provider ---
 
 export class AnthropicOAuthProvider {
+  // Takes a PDF as a native document block (decided by this adapter's wire protocol).
+  nativePdf = true;
   // input_tokens EXCLUDES cache_read_input_tokens (separate field) — add the
   // cache back for the real context footprint. See registry.mjs.
   static inputExcludesCache = true;

package/src/runtime/agent/orchestrator/providers/anthropic.mjs

@@ -22,9 +22,12 @@ import { getLlmDispatcher } from '../../../shared/llm/http-agent.mjs';
 import { loadAnthropic, _normalizeAnthropicModel, _setApiKeyCatalogMirror } from './anthropic-messages.mjs';
 import { ANTHROPIC_VERSION, MODELS } from './lib/anthropic-models.mjs';
 import { streamCallbacks } from './lib/send-callbacks.mjs';
+import { preparePdfTextForProvider } from './media-normalization.mjs';
 export { _test, _toAnthropicMessagesForTest } from './anthropic-messages.mjs';
 
 export class AnthropicProvider {
+  // Takes a PDF as a native document block (decided by this adapter's wire protocol).
+  nativePdf = true;
   // Anthropic reports usage.input_tokens EXCLUDING cache_read/cache_creation
   // (those are separate fields), so the live context-window footprint must
   // add cache_read back. See providerInputExcludesCache() in registry.mjs.
@@ -77,6 +80,9 @@ export class AnthropicProvider {
     // dispatch with an aborted-mid-flight tool_use would otherwise hit
     // the provider as a hard 400 (`tool_use ids ... without tool_result`).
     messages = sanitizeToolPairs(messages);
+    // The flag alone decides: an instance that takes no native PDF (a custom
+    // gateway, OpenCode Go's Anthropic route) gets the PDF as text.
+    messages = await preparePdfTextForProvider(messages, this);
     try {
       return await this._doSend(messages, model, tools, sendOpts);
     } catch (err) {

package/src/runtime/agent/orchestrator/providers/antigravity-oauth-login.mjs

@@ -11,6 +11,7 @@ import { createServer } from 'node:http';
 import { randomBytes } from 'node:crypto';
 import { setTimeout as delay } from 'node:timers/promises';
 import { createOAuthPkce, parseOAuthCodeInput } from './lib/oauth-pkce.mjs';
+import { OAUTH_PAGE_CONTENT_TYPE, oauthErrorHtml, oauthSuccessHtml } from './lib/oauth-page.mjs';
 import {
   AUTH_URL,
   CALLBACK_HOST,
@@ -34,9 +35,10 @@ import {
 } from './antigravity-oauth-tokens.mjs';
 
 const ONBOARD_INTERVAL_MS = 1_000;
-const CALLBACK_FAILURE_HTML =
-  '<html><body><h2>Antigravity sign-in was not completed.</h2>' +
-  '<p>Return to Mixdog for the error details and any account verification link.</p></body></html>';
+const CALLBACK_FAILURE_HTML = oauthErrorHtml(
+  'Antigravity sign-in was not completed.',
+  'Return to Mixdog for the error details and any account verification link.'
+);
 
 function extractProjectId(payload) {
   return typeof payload?.cloudaicompanionProject === 'string' ? payload.cloudaicompanionProject : '';
@@ -353,7 +355,7 @@ export async function beginOAuthLogin({
       const authorizationError = requestUrl.searchParams.get('error');
       if (authorizationError) {
         const detail = requestUrl.searchParams.get('error_description') || authorizationError;
-        res.writeHead(400, { 'Content-Type': 'text/html' });
+        res.writeHead(400, { 'Content-Type': OAUTH_PAGE_CONTENT_TYPE });
         res.end(CALLBACK_FAILURE_HTML);
         // A late denial must not cancel an already accepted code.
         if (!exchangePromise) {
@@ -369,12 +371,12 @@ export async function beginOAuthLogin({
       }
       try {
         await acceptCode(code);
-        res.writeHead(200, { 'Content-Type': 'text/html' });
-        res.end('<html><body><h2>Antigravity connected.</h2><p>You can close this tab.</p></body></html>');
+        res.writeHead(200, { 'Content-Type': OAUTH_PAGE_CONTENT_TYPE });
+        res.end(oauthSuccessHtml('Antigravity'));
       } catch {
         // The shared exchange reports its error through waitForCallback.
         // Do not interpolate provider-controlled text into browser HTML.
-        res.writeHead(500, { 'Content-Type': 'text/html' });
+        res.writeHead(500, { 'Content-Type': OAUTH_PAGE_CONTENT_TYPE });
         res.end(CALLBACK_FAILURE_HTML);
       }
     });

package/src/runtime/agent/orchestrator/providers/antigravity-oauth.mjs

@@ -63,6 +63,8 @@ async function storedAuth(options) {
 }
 
 export class AntigravityOAuthProvider {
+  // Takes a PDF as a native document block (decided by this adapter's wire protocol).
+  nativePdf = true;
   // usageMetadata.promptTokenCount is the total, cached tokens included.
   static inputExcludesCache = false;
   name = 'antigravity-oauth';

package/src/runtime/agent/orchestrator/providers/antigravity-request.mjs

@@ -1,6 +1,6 @@
 import { randomUUID, createHash } from 'node:crypto';
 import { createProviderReplay, providerReplayItems } from './lib/provider-replay.mjs';
-import { toGeminiContents, toGeminiTools, toGeminiToolConfig } from './gemini-schema.mjs';
+import { toGeminiContents, toGeminiRequestTools, toGeminiToolConfig } from './gemini-schema.mjs';
 import { geminiThinkingConfig } from './gemini-thinking.mjs';
 
 const THOUGHT_SIGNATURE_SENTINEL = 'skip_thought_signature_validator';
@@ -105,8 +105,9 @@ export function buildAntigravityRequest(messages, model, tools, opts = {}, proje
   };
   const request = { contents };
   if (systemText) request.systemInstruction = { role: 'user', parts: [{ text: systemText }] };
+  const requestTools = toGeminiRequestTools(tools, opts.nativeTools);
+  if (requestTools.length) request.tools = requestTools;
   if (tools?.length) {
-    request.tools = [toGeminiTools(tools)];
     request.toolConfig = toGeminiToolConfig(opts.toolChoice) || {
       functionCallingConfig: { mode: antigravityFunctionCallingMode() },
     };

package/src/runtime/agent/orchestrator/providers/auto-effort.mjs

@@ -0,0 +1,77 @@
+// Auto effort: turns the effort judge's difficulty distribution into this
+// turn's effort by moving along the model's effort ladder from a base effort.
+// Every turn starts again from the base, so a run of hard turns never
+// ratchets the effort upward.
+//
+// The base is `medium` on every model: raised only when the request needs it,
+// lowered when it is easy. The ladder is the model's supported efforts from
+// `low` up to the tier below the top: `none`/`minimal` switch thinking off and
+// `max`/`ultra` are reserved for an explicit user choice, so auto never picks
+// them. A chosen `max`/`ultra` is left untouched.
+
+const EFFORT_ORDER = Object.freeze(['none', 'minimal', 'low', 'medium', 'high', 'xhigh', 'max', 'ultra']);
+const FLOOR_INDEX = EFFORT_ORDER.indexOf('low');
+const RESERVED_TOP = new Set(['max', 'ultra']);
+
+export const AUTO_EFFORT_BASE = 'medium';
+
+/** The effort auto moves from: `medium`, unless the user chose `max`/`ultra`. */
+export function autoEffortBase(chosen) {
+  const effort = String(chosen ?? '')
+    .trim()
+    .toLowerCase();
+  return RESERVED_TOP.has(effort) ? effort : AUTO_EFFORT_BASE;
+}
+
+export const AUTO_EFFORT_MODES = Object.freeze(['off', 'observe', 'on']);
+
+// Below this top-class probability the judge is unsure and the default stays.
+export const AUTO_EFFORT_MIN_CONFIDENCE = 0.4;
+// xhigh costs far more than high, so "very hard" needs a firmer judge;
+// below this it is treated as "hard". 0.65 minimised the eval cost with a
+// false xhigh weighted three times a missed one.
+export const AUTO_EFFORT_VERY_HARD_CONFIDENCE = 0.65;
+
+// The judge rates four levels, each one ladder step from the base: easy -1
+// (low), normal 0 (medium), hard +1 (high), very hard +2 (xhigh).
+export const AUTO_EFFORT_LEVELS = Object.freeze(['easy', 'normal', 'hard', 'very hard']);
+const STEP_OF_LEVEL = [-1, 0, 1, 2];
+
+export function normalizeAutoEffortMode(value) {
+  const mode = String(value ?? '')
+    .trim()
+    .toLowerCase();
+  return AUTO_EFFORT_MODES.includes(mode) ? mode : 'off';
+}
+
+/** The efforts auto may choose for a model, in ascending order. */
+export function autoEffortLadder(options) {
+  const supported = new Set((options || []).map((value) => String(value).trim().toLowerCase()));
+  return EFFORT_ORDER.filter(
+    (level, index) => supported.has(level) && index >= FLOOR_INDEX && !RESERVED_TOP.has(level)
+  );
+}
+
+/** Ladder step for a judge distribution over the four levels (index 0 = easy). */
+export function judgedStep(probs) {
+  const values = Array.isArray(probs) && probs.length === AUTO_EFFORT_LEVELS.length ? probs.map(Number) : null;
+  if (!values || values.some((value) => !Number.isFinite(value))) return { step: 0, level: null, confidence: 0 };
+  const confidence = Math.max(...values);
+  if (confidence < AUTO_EFFORT_MIN_CONFIDENCE) return { step: 0, level: null, confidence };
+  let level = values.indexOf(confidence);
+  if (level === 3 && confidence < AUTO_EFFORT_VERY_HARD_CONFIDENCE) level = 2;
+  return { step: STEP_OF_LEVEL[level], level, confidence };
+}
+
+/**
+ * This turn's effort, or null when auto does not apply (the default lies
+ * outside the ladder). `effort === base` when the judge keeps the default.
+ */
+export function resolveAutoEffort({ base, options, probs }) {
+  const ladder = autoEffortLadder(options);
+  const at = ladder.indexOf(String(base ?? '').toLowerCase());
+  if (at < 0) return null;
+  const { step, level, confidence } = judgedStep(probs);
+  const effort = ladder[Math.max(0, Math.min(ladder.length - 1, at + step))];
+  return { base: ladder[at], effort, step, level, confidence: Number(confidence.toFixed(3)) };
+}

package/src/runtime/agent/orchestrator/providers/cursor.mjs

@@ -7,6 +7,7 @@ import {
   toOpenAIMessages,
   toOpenAITools,
 } from './openai-compat-wire.mjs';
+import { preparePdfTextForProvider } from './media-normalization.mjs';
 import { consumeCompatChatCompletionStream } from './openai-compat-stream.mjs';
 import { ensureChatToolPairs } from './lib/wire-pairing.mjs';
 import { cursorTokenExpiry, exchangeCursorToken, resolveCursorOAuthAccessToken } from './cursor-auth.mjs';
@@ -28,10 +29,10 @@ async function loadCursorRuntime() {
   return runtimePromise;
 }
 
-function toCursorMessages(messages, providerName) {
+function toCursorMessages(messages, providerName, { nativePdf } = {}) {
   const output = [];
   for (const message of messages || []) {
-    const converted = toOpenAIMessages([message], providerName);
+    const converted = toOpenAIMessages([message], providerName, { nativePdf });
     if (message?.role !== 'tool') {
       output.push(...converted);
       continue;
@@ -544,6 +545,9 @@ function selectCursorVariant(group, { effort = null, fast = false } = {}) {
 }
 
 class CursorProviderBase {
+  // Cursor's chat wire has no document block: PDFs lower to text.
+  nativePdf = false;
+
   static inputExcludesCache = false;
   name;
   config;
@@ -614,7 +618,7 @@ class CursorProviderBase {
       // Wire-level pairing guard: a call whose result never committed
       // (cancel/abort) is hard-rejected unpaired, so synthesize the
       // missing tool messages on the assembled array.
-      messages: ensureChatToolPairs(toCursorMessages(messages, this.name)),
+      messages: ensureChatToolPairs(toCursorMessages(messages, this.name, { nativePdf: this.nativePdf })),
       mixdog_session_id: sessionScope,
       stream: true,
       stream_options: { include_usage: true },
@@ -690,10 +694,12 @@ class CursorProviderBase {
       sendOpts.sessionId || sendOpts.providerCacheKey || sendOpts.promptCacheKey || `cursor-call:${randomUUID()}`
     );
     const openAiTools = tools?.length ? toOpenAITools(tools) : undefined;
-    const dispatch = () => {
+    const dispatch = async () => {
       noteRequestServiceTier(cursorSelectionIsFast(cursorSelection) ? 'fast' : '');
+      // Every attempt (retries included) prepares right before it lowers.
+      const prepared = await preparePdfTextForProvider(messages, this);
       return this._dispatchChat(
-        this._chatBody(messages, { cursorSelection, sessionScope, openAiTools, toolChoice: sendOpts.toolChoice }),
+        this._chatBody(prepared, { cursorSelection, sessionScope, openAiTools, toolChoice: sendOpts.toolChoice }),
         { runtime, accessToken, signal, sendOpts, openAiTools }
       );
     };

package/src/runtime/agent/orchestrator/providers/custom-provider.mjs

@@ -0,0 +1,165 @@
+// User-defined ("custom") providers. A custom provider is stored as a
+// secret-free config entry keyed by a generated `custom-<uuid>` id; the API key
+// lives in the keychain under that same id and is injected at load time. The
+// runtime reuses the existing OpenAI-compat / Anthropic engines, constructed
+// under the custom id so model routes and provider identity stay `custom-…`.
+
+import { ANTHROPIC_VERSION } from './lib/anthropic-models.mjs';
+import { assertSafeBaseURL } from './provider-base-url.mjs';
+import { listCompatModels } from './openai-compat-models.mjs';
+
+export const CUSTOM_PROVIDER_PROTOCOLS = Object.freeze(['openai-chat', 'openai-responses', 'anthropic']);
+
+function fail(message) {
+  throw new Error(`[custom-provider] ${message}`);
+}
+
+function text(value) {
+  return typeof value === 'string' ? value.trim() : '';
+}
+
+function positiveInt(value, label) {
+  if (value === undefined || value === null || value === '') return undefined;
+  const n = Number(value);
+  if (!Number.isInteger(n) || n <= 0) fail(`${label} must be a positive integer`);
+  return n;
+}
+
+function normalizeBaseURL(raw) {
+  const value = text(raw);
+  if (!value) fail('baseURL is required');
+  let url;
+  try {
+    url = new URL(value);
+  } catch {
+    fail(`invalid baseURL: ${value}`);
+  }
+  if (url.protocol !== 'https:' && url.protocol !== 'http:') fail('baseURL must use http or https');
+  if (url.username || url.password) fail('baseURL must not embed credentials');
+  if (url.search || url.hash || /[?#]/.test(value)) fail('baseURL must not contain a query or hash');
+  return assertSafeBaseURL(value.replace(/\/+$/, ''), 'custom');
+}
+
+function normalizeModels(raw, requireModels) {
+  if (raw === undefined || raw === null) raw = [];
+  if (!Array.isArray(raw)) fail('models must be an array');
+  const seen = new Set();
+  const models = raw.map((entry) => {
+    const id = text(entry?.id);
+    if (!id) fail('every model needs an id');
+    if (seen.has(id)) fail(`duplicate model id: ${id}`);
+    seen.add(id);
+    const name = text(entry.name);
+    const contextWindow = positiveInt(entry.contextWindow, `model ${id} contextWindow`);
+    const maxOutputTokens = positiveInt(entry.maxOutputTokens, `model ${id} maxOutputTokens`);
+    return {
+      id,
+      ...(name ? { name } : {}),
+      ...(contextWindow ? { contextWindow } : {}),
+      ...(maxOutputTokens ? { maxOutputTokens } : {}),
+    };
+  });
+  if (requireModels && models.length === 0) fail('at least one model is required');
+  return models;
+}
+
+export function normalizeCustomProviderConfig(input, { requireModels = true } = {}) {
+  if (!input || typeof input !== 'object') fail('config must be an object');
+  const name = text(input.name);
+  if (!name) fail('name is required');
+  const protocol = text(input.protocol);
+  if (!protocol) fail('protocol is required');
+  if (!CUSTOM_PROVIDER_PROTOCOLS.includes(protocol)) fail(`unsupported protocol: ${protocol}`);
+  return {
+    type: 'custom',
+    name,
+    protocol,
+    baseURL: normalizeBaseURL(input.baseURL),
+    models: normalizeModels(input.models, requireModels),
+    enabled: true,
+  };
+}
+
+function modelRow(id, m) {
+  return {
+    id: m.id,
+    name: m.name || m.id,
+    provider: id,
+    contextWindow: m.contextWindow || 0,
+    outputTokens: m.maxOutputTokens || null,
+  };
+}
+
+// Configured models win; an empty list falls back to protocol discovery.
+function withConfiguredModels(Base, discover) {
+  return class extends Base {
+    _customModels = [];
+    async listModels() {
+      if (!this._customModels.length) return discover(this);
+      if ('_enrichedModels' in this) this._enrichedModels = this._customModels;
+      return this._customModels.map((m) => ({ ...m }));
+    }
+    async isAvailable() {
+      return this._customModels.length ? true : super.isAvailable();
+    }
+    getCachedModelInfo(model) {
+      return this._customModels.find((m) => m.id === model) || super.getCachedModelInfo?.(model) || null;
+    }
+  };
+}
+
+async function discoverAnthropicModels(provider) {
+  const res = await fetch(`${provider.config.baseURL}/v1/models`, {
+    method: 'GET',
+    signal: AbortSignal.timeout(10_000),
+    headers: { 'x-api-key': provider.apiKey || '', 'anthropic-version': ANTHROPIC_VERSION },
+  });
+  if (!res.ok) throw Object.assign(new Error(`${provider.name} models ${res.status}`), { status: res.status });
+  const data = await res.json();
+  const items = Array.isArray(data?.data) ? data.data : [];
+  return items
+    .filter((m) => m?.id)
+    .map((m) => ({
+      id: m.id,
+      name: m.display_name || m.id,
+      provider: provider.name,
+      contextWindow: Number(m.max_input_tokens) > 0 ? Number(m.max_input_tokens) : 0,
+      outputTokens: Number(m.max_tokens) > 0 ? Number(m.max_tokens) : null,
+    }));
+}
+
+export async function createCustomProvider(id, config) {
+  const providerId = text(id);
+  if (!/^custom-.+/.test(providerId)) fail(`invalid custom provider id: ${id}`);
+  const cfg = normalizeCustomProviderConfig(config, { requireModels: false });
+  const engine = {
+    baseURL: cfg.baseURL,
+    apiKey: config.apiKey || undefined,
+    ...(config.preconnect === false ? { preconnect: false } : {}),
+  };
+  let provider;
+  if (cfg.protocol === 'anthropic') {
+    const { AnthropicProvider } = await import('./anthropic.mjs');
+    const Custom = withConfiguredModels(AnthropicProvider, discoverAnthropicModels);
+    // The Anthropic SDK appends /v1/messages itself; accept a /v1 base URL.
+    provider = new Custom({ ...engine, name: providerId, baseURL: cfg.baseURL.replace(/\/v1$/i, '') });
+    // An unknown third-party gateway behind the Anthropic wire: PDFs lower to text.
+    provider.nativePdf = false;
+  } else {
+    const { OpenAICompatProvider } = await import('./openai-compat.mjs');
+    const Base =
+      cfg.protocol === 'openai-responses'
+        ? class extends OpenAICompatProvider {
+            _doSend(messages, model, tools, sendOpts) {
+              return super._doSend(messages, model, tools, { ...(sendOpts || {}), compatWireApi: 'responses' });
+            }
+          }
+        : OpenAICompatProvider;
+    const Custom = withConfiguredModels(Base, (self) => listCompatModels(self, { throwOnError: true }));
+    provider = new Custom(providerId, engine);
+    if (cfg.models.length) provider.defaultModel = cfg.models[0].id;
+  }
+  provider._customModels = cfg.models.map((m) => modelRow(providerId, m));
+  provider.customConfig = cfg;
+  return provider;
+}

package/src/runtime/agent/orchestrator/providers/effort-configuration.mjs

@@ -88,11 +88,13 @@ function validSnapshot(value, provider, model, mode) {
   );
 }
 
-export function prepareTurnEffortConfiguration(session, provider) {
+// `turnEffort` overrides the session's saved effort for this turn only (auto
+// effort); the saved default itself is never changed here.
+export function prepareTurnEffortConfiguration(session, provider, turnEffort) {
   const config = provider?.config || {};
   const opts = { ...config, modelParameters: session.modelParameters || {} };
   const mode = effortConfigurationMode(session.provider, session.model, opts);
-  const effort = normalizedEffort(session.provider, session.model, session.effort);
+  const effort = normalizedEffort(session.provider, session.model, turnEffort ?? session.effort);
   if (!mode || !EFFORTS.has(effort)) return null;
   const first = (session.messages || []).find((message) =>
     validSnapshot(message?.meta?.[META_KEY], session.provider, session.model, mode)

package/src/runtime/agent/orchestrator/providers/gemini-request-body.mjs

@@ -9,7 +9,7 @@
  * gemini-schema.mjs.
  */
 import { geminiThinkingConfig } from './gemini-thinking.mjs';
-import { toGeminiContents, toGeminiNativeTools, toGeminiToolConfig, toGeminiTools } from './gemini-schema.mjs';
+import { toGeminiContents, toGeminiRequestTools, toGeminiToolConfig } from './gemini-schema.mjs';
 
 // Request pieces shared by the cached REST path and the SDK path.
 export function buildGeminiRequest(messages, useModel, tools, opts) {
@@ -29,11 +29,9 @@ export function buildGeminiRequest(messages, useModel, tools, opts) {
   const contents = toGeminiContents(chatMsgs, useModel);
   if (!contents.length) throw new Error('No messages to send');
 
-  const nativeGeminiTools = toGeminiNativeTools(opts.nativeTools);
-  const functionGeminiTools = tools?.length ? [toGeminiTools(tools)] : [];
-  const geminiTools =
-    nativeGeminiTools.length || functionGeminiTools.length ? [...nativeGeminiTools, ...functionGeminiTools] : undefined;
-  const toolConfig = functionGeminiTools.length ? toGeminiToolConfig(opts.toolChoice) : undefined;
+  const requestTools = toGeminiRequestTools(tools, opts.nativeTools);
+  const geminiTools = requestTools.length ? requestTools : undefined;
+  const toolConfig = tools?.length ? toGeminiToolConfig(opts.toolChoice) : undefined;
   return { generationConfig, systemInstruction, contents, geminiTools, toolConfig };
 }
 

package/src/runtime/agent/orchestrator/providers/gemini-schema.mjs

@@ -593,6 +593,13 @@ export function toGeminiNativeTools(nativeTools) {
   return out;
 }
 
+// The request `tools` array: hosted tools first, then one function-declaration
+// entry when function tools are present. Empty when neither is present.
+export function toGeminiRequestTools(tools, nativeTools) {
+  const functionTools = tools?.length ? [toGeminiTools(tools)] : [];
+  return [...toGeminiNativeTools(nativeTools), ...functionTools];
+}
+
 export function collectGeminiGroundingSources(candidate) {
   const out = [];
   const seen = new Set();

package/src/runtime/agent/orchestrator/providers/gemini.mjs

@@ -131,6 +131,8 @@ function throwIfGeminiAborted(signal) {
 }
 
 export class GeminiProvider {
+  // Takes a PDF as a native document block (decided by this adapter's wire protocol).
+  nativePdf = true;
   // promptTokenCount is the total (cachedContentTokenCount is a subset), so
   // input already includes cache. See registry.mjs.
   static inputExcludesCache = false;

package/src/runtime/agent/orchestrator/providers/grok-oauth-login.mjs

@@ -4,6 +4,7 @@ import { createServer } from 'node:http';
 import { randomBytes } from 'node:crypto';
 import { getLlmDispatcher } from '../../../shared/llm/http-agent.mjs';
 import { createOAuthPkce, parseOAuthCodeInput } from './lib/oauth-pkce.mjs';
+import { OAUTH_PAGE_CONTENT_TYPE, oauthSuccessHtml } from './lib/oauth-page.mjs';
 import {
   CLIENT_ID,
   SCOPE,
@@ -119,8 +120,8 @@ export async function beginOAuthLogin() {
         res.end('Invalid');
         return;
       }
-      res.writeHead(200, { 'Content-Type': 'text/html' });
-      res.end('<html><body><h2>Grok login successful! You can close this tab.</h2></body></html>');
+      res.writeHead(200, { 'Content-Type': OAUTH_PAGE_CONTENT_TYPE });
+      res.end(oauthSuccessHtml('Grok'));
       try {
         const tokens = await exchangeAuthorizationCode({ discovery, pkce, code });
         finish(tokens);

package/src/runtime/agent/orchestrator/providers/grok-oauth.mjs

@@ -259,6 +259,8 @@ async function ensureLatestGrokModel(provider) {
 let _modelRefreshInFlight = null;
 
 export class GrokOAuthProvider {
+  // No document block on this wire: a PDF is lowered to text before the request is built.
+  nativePdf = false;
   // OpenAI-compatible usage: prompt_tokens includes cached. See registry.mjs.
   static inputExcludesCache = false;
   name = 'grok-oauth';

package/src/runtime/agent/orchestrator/providers/lib/anthropic-image-input.mjs

@@ -2,14 +2,16 @@ import {
   API_IMAGE_MAX_BASE64_SIZE,
   IMAGE_MAX_WIDTH,
   IMAGE_MAX_HEIGHT,
-  imageMetadataText,
   resizeImageBuffer,
+  supersedingImageMetadataText,
 } from '../../tools/builtin/read-image-resize.mjs';
 
+import { isEnvironmentError } from '../../../../shared/environment-error.mjs';
+
 const MAX_INPUT_BASE64_SIZE = Math.ceil((64 * 1024 * 1024) / 3) * 4;
 
 export class AnthropicImagePreparationError extends Error {
-  constructor(path, detail, cause) {
+  constructor(path, detail, cause, failingImageData) {
     super(
       `Anthropic image preparation failed at ${path}: ${detail}. The original image and conversation were not changed.`,
       { cause }
@@ -17,12 +19,28 @@ export class AnthropicImagePreparationError extends Error {
     this.name = 'AnthropicImagePreparationError';
     this.code = 'ANTHROPIC_IMAGE_PREPARATION_FAILED';
     this.status = 400;
+    // Identifies the rejected image for recovery; never part of the message.
+    Object.defineProperty(this, 'failingImageData', { value: failingImageData, enumerable: false });
+  }
+}
+
+// The image may be fine; this machine cannot resize it (broken sharp runtime,
+// out of memory...). Not an image rejection: recovery must not strip anything.
+export class AnthropicImageRuntimeError extends Error {
+  constructor(path, cause) {
+    super(
+      `Anthropic image preparation unavailable at ${path}: image resizing is unavailable; repair the sharp runtime. The original image and conversation were not changed.`,
+      { cause }
+    );
+    this.name = 'AnthropicImageRuntimeError';
+    this.code = 'ANTHROPIC_IMAGE_RUNTIME_UNAVAILABLE';
+    this.status = 400;
   }
 }
 
 // Work on the lowered request, not stored history: this covers attachments,
-// tool results, replayed images, and provider switches alike. Keep the 2000px
-// ceiling independent of image count so crossing 20 images never invalidates
+// tool results, replayed images, and provider switches alike. Keep the
+// IMAGE_MAX_WIDTH x IMAGE_MAX_HEIGHT display box (1568px) independent of image count so crossing 20 images never invalidates
 // an earlier image or changes its cached rendition.
 export async function prepareAnthropicImages(messages, { signal } = {}) {
   if (!Array.isArray(messages)) return messages;
@@ -64,12 +82,16 @@ export async function prepareAnthropicImages(messages, { signal } = {}) {
           { profile: 'anthropic' }
         );
       } catch (error) {
-        throw new AnthropicImagePreparationError(partPath, 'image could not be decoded; reattach a valid image', error);
+        if (isEnvironmentError(error)) throw new AnthropicImageRuntimeError(partPath, error);
+        throw new AnthropicImagePreparationError(
+          partPath,
+          'image could not be decoded; reattach a valid image',
+          error,
+          source.data
+        );
       }
       signal?.throwIfAborted();
-      if (!resized) {
-        throw new AnthropicImagePreparationError(partPath, 'image resizing is unavailable; repair the sharp runtime');
-      }
+      if (!resized) throw new AnthropicImageRuntimeError(partPath);
       const dims = resized.dimensions;
       if (
         !dims?.displayWidth ||
@@ -80,7 +102,9 @@ export async function prepareAnthropicImages(messages, { signal } = {}) {
       ) {
         throw new AnthropicImagePreparationError(
           partPath,
-          'image still exceeds the supported size; use a smaller image'
+          'image still exceeds the supported size; use a smaller image',
+          undefined,
+          source.data
         );
       }
       if (resized.data === source.data && resized.mimeType === source.media_type) {
@@ -89,10 +113,7 @@ export async function prepareAnthropicImages(messages, { signal } = {}) {
       }
       changed = true;
       if (dims.originalWidth !== dims.displayWidth || dims.originalHeight !== dims.displayHeight) {
-        next.push({
-          type: 'text',
-          text: `${imageMetadataText(dims)} These display dimensions supersede any earlier display-size annotation for the following image.`,
-        });
+        next.push({ type: 'text', text: supersedingImageMetadataText(dims) });
       }
       // Cache markers stay attached to the same logical block. No
       // sanitizer or reordering runs after this byte-preparation pass.