mixdog 0.9.52 → 0.9.53

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

@@ -31,6 +31,7 @@ import { OpenAICompatProvider } from './openai-compat.mjs';
 import { createTimeoutSignal } from '../stall-policy.mjs';
 import { populateHttpStatusFromMessage } from './retry-classifier.mjs';
 import { getLlmDispatcher, preconnect } from '../../../shared/llm/http-agent.mjs';
+import { normalizeGrokToolSchemas } from './lib/grok-tool-schema.mjs';
 
 // --- Constants ---
 // xAI's shared OAuth client. The consent screen renders this as "Grok Build".
@@ -584,120 +585,6 @@ export async function ensureLatestGrokModel(provider) {
 
 let _modelRefreshInFlight = null;
 
-// Grok's gRPC tool registry rejects a root anyOf/oneOf when even one branch is
-// not an object. Keep this adapter local to OAuth Grok requests: other
-// providers may support the original union schema. Tool definitions are never
-// mutated, so callers can safely reuse them for later requests.
-function schemasDeepEqual(left, right) {
-    if (Object.is(left, right)) return true;
-    if (!left || !right || typeof left !== 'object' || typeof right !== 'object') return false;
-    if (Array.isArray(left) || Array.isArray(right)) {
-        return Array.isArray(left) && Array.isArray(right)
-            && left.length === right.length
-            && left.every((value, index) => schemasDeepEqual(value, right[index]));
-    }
-    const leftKeys = Object.keys(left).sort();
-    const rightKeys = Object.keys(right).sort();
-    return leftKeys.length === rightKeys.length
-        && leftKeys.every((key, index) => key === rightKeys[index]
-            && schemasDeepEqual(left[key], right[key]));
-}
-
-function pureAnyOfAlternatives(schema) {
-    return schema && typeof schema === 'object' && !Array.isArray(schema)
-        && Object.keys(schema).length === 1
-        && Array.isArray(schema.anyOf)
-        ? schema.anyOf
-        : [schema];
-}
-
-function mergeGrokObjectBranchProperties(objectBranches) {
-    const properties = {};
-    for (const branch of objectBranches) {
-        for (const [name, schema] of Object.entries(branch.properties || {})) {
-            if (!Object.prototype.hasOwnProperty.call(properties, name)) {
-                properties[name] = schema;
-                continue;
-            }
-            if (schemasDeepEqual(properties[name], schema)) continue;
-            const alternatives = [
-                ...pureAnyOfAlternatives(properties[name]),
-                ...pureAnyOfAlternatives(schema),
-            ];
-            const deduped = alternatives.reduce(
-                (unique, alternative) => unique.some(item => schemasDeepEqual(item, alternative))
-                    ? unique
-                    : [...unique, alternative],
-                [],
-            );
-            properties[name] = deduped.length === 1 ? deduped[0] : { anyOf: deduped };
-        }
-    }
-    return properties;
-}
-
-function normalizeGrokToolSchema(schema) {
-    if (!schema || typeof schema !== 'object' || Array.isArray(schema)
-        || (!Array.isArray(schema.anyOf) && !Array.isArray(schema.oneOf))) {
-        return schema;
-    }
-
-    const { anyOf, oneOf, ...root } = schema;
-    const branches = [...(Array.isArray(anyOf) ? anyOf : []), ...(Array.isArray(oneOf) ? oneOf : [])];
-    const objectBranches = branches.filter((branch) => branch && typeof branch === 'object' && !Array.isArray(branch)
-        && (branch.type === 'object'
-            || (Array.isArray(branch.type) && branch.type.includes('object'))
-            || (branch.properties && typeof branch.properties === 'object')));
-
-    // A function's arguments must be an object even if its original union has
-    // no explicit object alternative. The permissive fallback still retains
-    // root-level metadata such as description and additionalProperties.
-    if (!objectBranches.length) {
-        return {
-            ...root,
-            type: 'object',
-            ...(!Object.prototype.hasOwnProperty.call(root, 'additionalProperties')
-                ? { additionalProperties: true }
-                : {}),
-        };
-    }
-
-    const properties = objectBranches.some(branch => branch.properties) || root.properties
-        ? {
-            ...mergeGrokObjectBranchProperties(objectBranches),
-            ...(root.properties || {}),
-        }
-        : undefined;
-    const branchRequiredInEvery = (Array.isArray(objectBranches[0].required) ? objectBranches[0].required : [])
-        .filter(key => objectBranches.every(branch => Array.isArray(branch.required) && branch.required.includes(key)));
-    const required = [...new Set([
-        ...(Array.isArray(root.required) ? root.required : []),
-        ...branchRequiredInEvery,
-    ])];
-    const { properties: _rootProperties, required: _rootRequired, ...rootWithoutPropertiesOrRequired } = root;
-    const mergedObjectBranches = Object.assign({}, ...objectBranches);
-    const {
-        properties: _branchProperties,
-        required: _branchRequired,
-        ...mergedObjectBranchesWithoutPropertiesOrRequired
-    } = mergedObjectBranches;
-    return {
-        ...mergedObjectBranchesWithoutPropertiesOrRequired,
-        ...rootWithoutPropertiesOrRequired,
-        type: 'object',
-        ...(properties ? { properties } : {}),
-        ...(required.length ? { required } : {}),
-    };
-}
-
-function normalizeGrokToolSchemas(tools) {
-    if (!Array.isArray(tools)) return tools;
-    return tools.map((tool) => {
-        const inputSchema = normalizeGrokToolSchema(tool?.inputSchema);
-        return inputSchema === tool?.inputSchema ? tool : { ...tool, inputSchema };
-    });
-}
-
 export class GrokOAuthProvider {
     // OpenAI-compatible usage: prompt_tokens includes cached. See registry.mjs.
     static inputExcludesCache = false;
@@ -840,7 +727,10 @@ export class GrokOAuthProvider {
                 process.stderr.write('[grok-oauth] 401, force-refreshing token...\n');
                 const fresh = await this.ensureAuth({ forceRefresh: true });
                 const retryInner = this._ensureInner(fresh.access_token, useModel);
-                return await retryInner._doSend(messages, useModel, grokTools, sendOpts);
+                const retryOpts = err?.__warmup?.usage
+                    ? { ...(sendOpts || {}), _carriedWarmup: err.__warmup }
+                    : sendOpts;
+                return await retryInner._doSend(messages, useModel, grokTools, retryOpts);
             }
             throw err;
         }

package/src/runtime/agent/orchestrator/providers/lib/anthropic-request-utils.mjs

@@ -0,0 +1,224 @@
+import { providerNativeToolPrefixCount } from '../../../../../session-runtime/provider-request-tools.mjs';
+
+export const ANTHROPIC_CACHE_TTL_STABLE = { type: 'ephemeral', ttl: '1h' };
+export const ANTHROPIC_CACHE_TTL_VOLATILE = { type: 'ephemeral' };
+
+export function appendAnthropicCacheControl(content, ttl = ANTHROPIC_CACHE_TTL_VOLATILE) {
+    const withCacheControl = (block) => {
+        if (!block || typeof block !== 'object' || block.cache_control) return block;
+        return { ...block, cache_control: ttl };
+    };
+    if (Array.isArray(content)) {
+        if (content.length === 0) return content;
+        const next = [...content];
+        next[next.length - 1] = withCacheControl(next[next.length - 1]);
+        return next;
+    }
+    if (typeof content === 'string') {
+        return [withCacheControl({ type: 'text', text: content })];
+    }
+    return content;
+}
+
+export function resolveAnthropicCacheTtls(opts) {
+    const strategy = opts?.cacheStrategy || {};
+    const pick = (layer, fallback) => {
+        const value = strategy[layer];
+        if (value === '1h') return ANTHROPIC_CACHE_TTL_STABLE;
+        if (value === '5m') return ANTHROPIC_CACHE_TTL_VOLATILE;
+        if (value === 'none') return null;
+        return fallback;
+    };
+    const resolved = {
+        tools: pick('tools', null),
+        system: pick('system', ANTHROPIC_CACHE_TTL_STABLE),
+        tier3: pick('tier3', ANTHROPIC_CACHE_TTL_STABLE),
+        messages: pick('messages', ANTHROPIC_CACHE_TTL_STABLE),
+    };
+    const ttlRank = (ttl) => (ttl === ANTHROPIC_CACHE_TTL_STABLE ? 2 : 1);
+    let minRank = Infinity;
+    for (const layer of ['system', 'tier3', 'messages']) {
+        if (!resolved[layer]) continue;
+        const rank = ttlRank(resolved[layer]);
+        if (rank > minRank) resolved[layer] = ANTHROPIC_CACHE_TTL_VOLATILE;
+        else minRank = rank;
+    }
+    return resolved;
+}
+
+export function clampAnthropicThinkingBudget(value, maxTokens) {
+    const desired = Math.floor(Number(value));
+    const max = Math.floor(Number(maxTokens));
+    if (!Number.isFinite(desired) || desired <= 0 || !Number.isFinite(max)) return null;
+    const ceiling = max - 1024;
+    if (ceiling < 1024) return null;
+    return Math.max(1024, Math.min(desired, ceiling));
+}
+
+export function sanitizeAnthropicInputSchema(schema, toolName, logTag) {
+    if (!schema || typeof schema !== 'object') {
+        return { type: 'object', properties: {} };
+    }
+    const compound = schema.oneOf || schema.anyOf || schema.allOf;
+    if (!compound) return structuredClone(schema);
+    const mergedProps = { ...(schema.properties && typeof schema.properties === 'object' ? schema.properties : {}) };
+    const branchDescs = [];
+    for (const branch of Array.isArray(compound) ? compound : []) {
+        if (branch && typeof branch === 'object' && branch.properties) {
+            Object.assign(mergedProps, branch.properties);
+        }
+        if (branch && typeof branch === 'object') {
+            const parts = [];
+            if (branch.description) parts.push(branch.description);
+            else if (branch.type) parts.push(`type:${branch.type}`);
+            if (parts.length) branchDescs.push(parts.join(' '));
+        }
+    }
+    const compoundKey = schema.oneOf ? 'oneOf' : schema.anyOf ? 'anyOf' : 'allOf';
+    let description = schema.description || '';
+    if (branchDescs.length) {
+        const parts = [];
+        let used = 0;
+        for (let i = 0; i < branchDescs.length; i++) {
+            const value = `(variant ${i + 1}: ${branchDescs[i]})`;
+            if (used + value.length + (parts.length ? 1 : 0) > 500) break;
+            parts.push(value);
+            used += value.length + (parts.length > 1 ? 1 : 0);
+        }
+        const addition = parts.join(' ');
+        if (addition) description = description ? `${description} ${addition}` : addition;
+    }
+    if (process.env.MIXDOG_DEBUG_SESSION_LOG) {
+        process.stderr.write(
+            `[${logTag}-sanitizer] tool="${toolName ?? ''}" compound="${compoundKey}" branches=${Array.isArray(compound) ? compound.length : 0} mergedProps=${Object.keys(mergedProps).length}\n`
+        );
+    }
+    return {
+        type: 'object',
+        ...(description ? { description } : {}),
+        properties: mergedProps,
+    };
+}
+
+function toAnthropicTools(tools, logTag) {
+    return tools.map((tool) => {
+        const out = {
+            name: tool.name,
+            description: tool.description,
+            input_schema: sanitizeAnthropicInputSchema(tool.inputSchema, tool.name, logTag),
+        };
+        if (tool.deferLoading === true || tool.defer_loading === true) out.defer_loading = true;
+        return out;
+    });
+}
+
+export function toAnthropicToolChoice(toolChoice) {
+    return toolChoice === 'none' ? { type: 'none' } : undefined;
+}
+
+export function deferredAnthropicTools(activeTools, messages, opts, provider) {
+    if (opts?.session?.deferredNativeTools !== true) return [];
+    if (!Array.isArray(activeTools) || activeTools.length === 0) return [];
+    const active = new Set(activeTools.map((tool) => String(tool?.name || '').trim()).filter(Boolean));
+    const anthropicNative = new Set(['anthropic', 'anthropic-oauth']);
+    const discovered = new Set(
+        Array.isArray(opts?.session?.deferredDiscoveredTools)
+            ? opts.session.deferredDiscoveredTools.map((name) => String(name || '').trim()).filter(Boolean)
+            : [],
+    );
+    for (const message of Array.isArray(messages) ? messages : []) {
+        const native = message?.nativeToolSearch;
+        const source = String(native?.provider || '').toLowerCase();
+        if (source && source !== provider
+            && !(anthropicNative.has(source) && anthropicNative.has(provider))) continue;
+        for (const name of Array.isArray(native?.toolReferences) ? native.toolReferences : []) {
+            const key = String(name || '').trim();
+            if (key) discovered.add(key);
+        }
+    }
+    const catalog = Array.isArray(opts.session.deferredToolCatalog) ? opts.session.deferredToolCatalog : [];
+    return catalog
+        .filter((tool) => tool?.name && discovered.has(String(tool.name)) && !active.has(String(tool.name)))
+        .map((tool) => ({ ...tool, deferLoading: true }));
+}
+
+export function requestAnthropicTools(tools, messages, opts, provider) {
+    const activeTools = Array.isArray(tools) ? tools : [];
+    if (opts?.providerToolSnapshotAuthoritative === true) {
+        const nativePrefixCount = providerNativeToolPrefixCount(
+            activeTools,
+            opts.providerNativeToolPrefixCount,
+        );
+        return [
+            ...activeTools.slice(0, nativePrefixCount),
+            ...toAnthropicTools(activeTools.slice(nativePrefixCount), provider),
+        ];
+    }
+    const deferredTools = deferredAnthropicTools(activeTools, messages, opts, provider);
+    const nativeTools = Array.isArray(opts?.nativeTools)
+        ? opts.nativeTools.filter((tool) => tool && typeof tool === 'object')
+        : [];
+    return [
+        ...nativeTools,
+        ...toAnthropicTools([...activeTools, ...deferredTools], provider),
+    ];
+}
+
+export function applyAnthropicCacheMarkers(sanitizedMessages, {
+    messageTtl = ANTHROPIC_CACHE_TTL_VOLATILE,
+    messageSlots = 1,
+} = {}) {
+    if (!Array.isArray(sanitizedMessages) || sanitizedMessages.length === 0) {
+        return sanitizedMessages;
+    }
+    const firstText = (content) => {
+        if (typeof content === 'string') return content;
+        if (Array.isArray(content)) {
+            const first = content.find((block) => block?.type === 'text');
+            return first && typeof first.text === 'string' ? first.text : '';
+        }
+        return '';
+    };
+    const isSystemReminder = (content) => firstText(content).startsWith('<system-reminder>');
+    const hasUserText = (message) => {
+        if (message?.role !== 'user' || isSystemReminder(message.content)) return false;
+        if (typeof message.content === 'string') return message.content.trim().length > 0;
+        if (!Array.isArray(message.content)) return false;
+        return message.content.some((block) => block?.type === 'text'
+            && typeof block.text === 'string' && block.text.trim().length > 0);
+    };
+    const previousUserTextAnchorIdx = () => {
+        for (let i = sanitizedMessages.length - 2; i >= 0; i--) {
+            if (hasUserText(sanitizedMessages[i])) return i;
+        }
+        return -1;
+    };
+    const latestToolResultTailIdx = () => {
+        for (let i = sanitizedMessages.length - 1; i >= 0; i--) {
+            const message = sanitizedMessages[i];
+            if (message?.role !== 'user' || !Array.isArray(message.content) || message.content.length === 0) continue;
+            if (message.content[message.content.length - 1]?.type === 'tool_result') return i;
+        }
+        return -1;
+    };
+    const firstRequestUserPromptIdx = () => {
+        if (latestToolResultTailIdx() !== -1 || previousUserTextAnchorIdx() !== -1) return -1;
+        const tailIdx = sanitizedMessages.length - 1;
+        return hasUserText(sanitizedMessages[tailIdx]) ? tailIdx : -1;
+    };
+    if (messageTtl !== null) {
+        const slots = Math.max(0, Math.min(4, Number(messageSlots) || 0));
+        const marked = new Set();
+        const candidates = [latestToolResultTailIdx(), previousUserTextAnchorIdx(), firstRequestUserPromptIdx()];
+        for (const idx of candidates) {
+            if (slots <= 0) break;
+            if (idx < 0 || marked.has(idx)) continue;
+            const message = sanitizedMessages[idx];
+            if (messageTtl?.ttl === '1h' && isSystemReminder(message?.content)) continue;
+            message.content = appendAnthropicCacheControl(message.content, messageTtl);
+            marked.add(idx);
+            if (marked.size >= slots) break;
+        }
+    }
+    return sanitizedMessages;
+}

package/src/runtime/agent/orchestrator/providers/lib/env-utils.mjs

@@ -0,0 +1,6 @@
+export function envPositiveInt(name, fallback) {
+    const raw = process.env[name];
+    if (raw == null || raw === '') return fallback;
+    const value = Number(raw);
+    return Number.isFinite(value) && value > 0 ? Math.floor(value) : fallback;
+}

package/src/runtime/agent/orchestrator/providers/lib/gemini-model-catalog.mjs

@@ -0,0 +1,119 @@
+import { getLlmDispatcher } from '../../../../shared/llm/http-agent.mjs';
+import { makeModelCache } from '../model-cache.mjs';
+
+export const GEMINI_MODELS = [
+    { id: 'gemini-3-flash-preview', name: 'Gemini 3 Flash Preview', provider: 'gemini', contextWindow: 1048576 },
+    { id: 'gemini-3.1-pro-preview', name: 'Gemini 3.1 Pro Preview', provider: 'gemini', contextWindow: 1048576 },
+    { id: 'gemini-3-pro-preview', name: 'Gemini 3 Pro Preview', provider: 'gemini', contextWindow: 1048576 },
+    { id: 'gemini-2.5-flash', name: 'Gemini 2.5 Flash', provider: 'gemini', contextWindow: 1048576 },
+    { id: 'gemini-2.5-pro', name: 'Gemini 2.5 Pro', provider: 'gemini', contextWindow: 1048576 },
+];
+
+export const DEFAULT_GEMINI_MODEL = GEMINI_MODELS[0].id;
+
+export const geminiModelCache = makeModelCache({
+    fileName: 'gemini-models.json',
+    ttlMs: 24 * 60 * 60_000,
+    version: 2,
+});
+
+export async function fetchGeminiModelPages(apiKey, fetchFn = fetch) {
+    const items = [];
+    let pageToken = '';
+    do {
+        const params = new URLSearchParams({ key: apiKey, pageSize: '1000' });
+        if (pageToken) params.set('pageToken', pageToken);
+        const url = `https://generativelanguage.googleapis.com/v1beta/models?${params}`;
+        const res = await fetchFn(url, {
+            signal: AbortSignal.timeout(60_000),
+            dispatcher: getLlmDispatcher(),
+        });
+        if (!res.ok) throw new Error(`gemini list_models ${res.status}`);
+        const data = await res.json();
+        if (Array.isArray(data?.models)) items.push(...data.models);
+        pageToken = typeof data?.nextPageToken === 'string' ? data.nextPageToken : '';
+    } while (pageToken);
+    return items;
+}
+
+function compareVersion(a, b) {
+    const na = (a.match(/gemini-(\d+)(?:\.(\d+))?/) || []).slice(1).map(Number);
+    const nb = (b.match(/gemini-(\d+)(?:\.(\d+))?/) || []).slice(1).map(Number);
+    for (let i = 0; i < Math.max(na.length, nb.length); i++) {
+        if ((na[i] || 0) !== (nb[i] || 0)) return (na[i] || 0) - (nb[i] || 0);
+    }
+    return a.localeCompare(b);
+}
+
+function markLatest(models) {
+    const byFamily = new Map();
+    for (const model of models) {
+        if (!model?.id) continue;
+        const current = byFamily.get(model.family);
+        if (!current || compareVersion(model.id, current.id) > 0) {
+            byFamily.set(model.family, model);
+        }
+    }
+    for (const model of byFamily.values()) model.latest = true;
+}
+
+export function resolveLatestGeminiModel() {
+    const cached = geminiModelCache.loadSync();
+    if (!Array.isArray(cached)) return null;
+    let best = null;
+    for (const model of cached) {
+        if (!model?.id || model.family !== 'gemini-flash') continue;
+        if (!best || compareVersion(model.id, best.id) > 0) best = model;
+    }
+    return best?.id || null;
+}
+
+export async function ensureLatestGeminiModel(provider) {
+    let model = resolveLatestGeminiModel();
+    if (model) return model;
+    await provider._refreshModelCache();
+    model = resolveLatestGeminiModel();
+    if (model) return model;
+    throw new Error('[gemini] model catalog unavailable after warmup — cannot resolve default model');
+}
+
+export async function fetchAndCacheGeminiModels({
+    apiKey,
+    fetchFn,
+    modelCache,
+    catalogForceRefresh,
+}) {
+    const items = await fetchGeminiModelPages(apiKey, fetchFn);
+    const normalized = items
+        .filter(model => (model?.name || '').includes('gemini'))
+        .filter(model => !Array.isArray(model?.supportedGenerationMethods)
+            || model.supportedGenerationMethods.includes('generateContent'))
+        .filter(model => !/embedding|aqa|imagen|robotics|computer-use/.test(model?.name || ''))
+        .map(model => {
+            const id = (model.name || '').replace(/^models\//, '');
+            const family = /flash-lite/.test(id) ? 'gemini-flash-lite'
+                : /flash/.test(id) ? 'gemini-flash'
+                : /pro/.test(id) ? 'gemini-pro'
+                : 'gemini';
+            return {
+                id,
+                display: model.displayName || id,
+                family,
+                provider: 'gemini',
+                contextWindow: model.inputTokenLimit || null,
+                outputTokens: model.outputTokenLimit || null,
+                tier: 'version',
+                latest: false,
+                description: model.description || '',
+            };
+        });
+    markLatest(normalized);
+    const { enrichModels } = await import('../model-catalog.mjs');
+    const { sanitizeModelList } = await import('../model-list-sanitize.mjs');
+    const enriched = sanitizeModelList(await enrichModels(normalized, {
+        fetchFn,
+        force: catalogForceRefresh === true,
+    }), { provider: 'gemini' });
+    modelCache.save(enriched);
+    return enriched;
+}

package/src/runtime/agent/orchestrator/providers/lib/grok-tool-schema.mjs

@@ -0,0 +1,109 @@
+// Grok's gRPC tool registry rejects a root anyOf/oneOf when even one branch
+// is not an object. Tool definitions are never mutated.
+
+function schemasDeepEqual(left, right) {
+    if (Object.is(left, right)) return true;
+    if (!left || !right || typeof left !== 'object' || typeof right !== 'object') return false;
+    if (Array.isArray(left) || Array.isArray(right)) {
+        return Array.isArray(left) && Array.isArray(right)
+            && left.length === right.length
+            && left.every((value, index) => schemasDeepEqual(value, right[index]));
+    }
+    const leftKeys = Object.keys(left).sort();
+    const rightKeys = Object.keys(right).sort();
+    return leftKeys.length === rightKeys.length
+        && leftKeys.every((key, index) => key === rightKeys[index]
+            && schemasDeepEqual(left[key], right[key]));
+}
+
+function pureAnyOfAlternatives(schema) {
+    return schema && typeof schema === 'object' && !Array.isArray(schema)
+        && Object.keys(schema).length === 1
+        && Array.isArray(schema.anyOf)
+        ? schema.anyOf
+        : [schema];
+}
+
+function mergeObjectBranchProperties(objectBranches) {
+    const properties = {};
+    for (const branch of objectBranches) {
+        for (const [name, schema] of Object.entries(branch.properties || {})) {
+            if (!Object.prototype.hasOwnProperty.call(properties, name)) {
+                properties[name] = schema;
+                continue;
+            }
+            if (schemasDeepEqual(properties[name], schema)) continue;
+            const alternatives = [
+                ...pureAnyOfAlternatives(properties[name]),
+                ...pureAnyOfAlternatives(schema),
+            ];
+            const deduped = alternatives.reduce(
+                (unique, alternative) => unique.some(item => schemasDeepEqual(item, alternative))
+                    ? unique
+                    : [...unique, alternative],
+                [],
+            );
+            properties[name] = deduped.length === 1 ? deduped[0] : { anyOf: deduped };
+        }
+    }
+    return properties;
+}
+
+function normalizeGrokToolSchema(schema) {
+    if (!schema || typeof schema !== 'object' || Array.isArray(schema)
+        || (!Array.isArray(schema.anyOf) && !Array.isArray(schema.oneOf))) {
+        return schema;
+    }
+
+    const { anyOf, oneOf, ...root } = schema;
+    const branches = [...(Array.isArray(anyOf) ? anyOf : []), ...(Array.isArray(oneOf) ? oneOf : [])];
+    const objectBranches = branches.filter((branch) => branch && typeof branch === 'object' && !Array.isArray(branch)
+        && (branch.type === 'object'
+            || (Array.isArray(branch.type) && branch.type.includes('object'))
+            || (branch.properties && typeof branch.properties === 'object')));
+
+    if (!objectBranches.length) {
+        return {
+            ...root,
+            type: 'object',
+            ...(!Object.prototype.hasOwnProperty.call(root, 'additionalProperties')
+                ? { additionalProperties: true }
+                : {}),
+        };
+    }
+
+    const properties = objectBranches.some(branch => branch.properties) || root.properties
+        ? {
+            ...mergeObjectBranchProperties(objectBranches),
+            ...(root.properties || {}),
+        }
+        : undefined;
+    const branchRequiredInEvery = (Array.isArray(objectBranches[0].required) ? objectBranches[0].required : [])
+        .filter(key => objectBranches.every(branch => Array.isArray(branch.required) && branch.required.includes(key)));
+    const required = [...new Set([
+        ...(Array.isArray(root.required) ? root.required : []),
+        ...branchRequiredInEvery,
+    ])];
+    const { properties: _rootProperties, required: _rootRequired, ...rootWithoutPropertiesOrRequired } = root;
+    const mergedObjectBranches = Object.assign({}, ...objectBranches);
+    const {
+        properties: _branchProperties,
+        required: _branchRequired,
+        ...mergedObjectBranchesWithoutPropertiesOrRequired
+    } = mergedObjectBranches;
+    return {
+        ...mergedObjectBranchesWithoutPropertiesOrRequired,
+        ...rootWithoutPropertiesOrRequired,
+        type: 'object',
+        ...(properties ? { properties } : {}),
+        ...(required.length ? { required } : {}),
+    };
+}
+
+export function normalizeGrokToolSchemas(tools) {
+    if (!Array.isArray(tools)) return tools;
+    return tools.map((tool) => {
+        const inputSchema = normalizeGrokToolSchema(tool?.inputSchema);
+        return inputSchema === tool?.inputSchema ? tool : { ...tool, inputSchema };
+    });
+}

package/src/runtime/agent/orchestrator/providers/lib/openai-tool-args.mjs

@@ -0,0 +1,70 @@
+export function truncatedCompatStreamError(label, detail) {
+    return Object.assign(
+        new Error(`${label} SSE stream truncated${detail ? `: ${detail}` : ''}`),
+        { name: 'TruncatedStreamError', code: 'TRUNCATED_STREAM', truncatedStream: true },
+    );
+}
+
+// Invalid-tool-args marker: completed-but-malformed tool_call arguments JSON must NOT throw
+// (kills the turn) NOR be silently swallowed to `{}`. Instead the parse
+// failure is carried as data on the tool call's `arguments` slot so the
+// dispatch loop can turn it into an is_error tool_result and let the model
+// re-issue the call with valid JSON in the SAME turn (follow-up retry).
+//   { __invalidToolArgs: true, __rawArguments: <raw string>, __parseError: <msg> }
+export function makeInvalidToolArgsMarker(rawArguments, parseError) {
+    return {
+        __invalidToolArgs: true,
+        __rawArguments: typeof rawArguments === 'string' ? rawArguments : String(rawArguments ?? ''),
+        __parseError: typeof parseError === 'string' ? parseError : String(parseError ?? 'parse error'),
+    };
+}
+export function isInvalidToolArgsMarker(value) {
+    return !!value && typeof value === 'object' && value.__invalidToolArgs === true;
+}
+/** Model-facing tool_result text for a tool call whose arguments failed to
+ * parse; instructs the model to retry with valid JSON in the same turn. */
+export function formatInvalidToolArgsResult(call) {
+    const name = call?.name || 'tool';
+    const detail = call?.arguments?.__parseError || 'arguments were not valid JSON';
+    return `The arguments provided to \`${name}\` are invalid JSON and could not be parsed: ${detail}. Re-issue this tool call with valid JSON arguments.`;
+}
+
+/** Completed tool_call.arguments must be valid JSON; empty/missing → {}.
+ * @param {any} raw - raw arguments value (string or object)
+ * @param {string} label - provider label for error messages
+ * @param {{id?:string,name?:string,index?:number,finishReason?:string}} [meta] - optional tool-call identity for diagnostics.
+ *   When `meta.finishReason` is set, a completion/finish signal was observed for
+ *   the call: a JSON.parse failure is then deterministic bad JSON (permanent),
+ *   not a mid-stream truncation (retryable). */
+export function parseCompletedToolCallArgumentsJson(raw, label, meta) {
+    const text = typeof raw === 'string' ? raw : (raw == null ? '' : String(raw));
+    const src = text === '' ? '{}' : text;
+    try {
+        return JSON.parse(src);
+    } catch (err) {
+        const preview = text.length <= 64
+            ? text
+            : text.slice(0, 32) + '...' + text.slice(-32);
+        const detailParts = [`invalid tool_call arguments JSON: len=${text.length} preview=${JSON.stringify(preview)}`];
+        if (meta) {
+            const m = {};
+            if (meta.id) m.id = meta.id;
+            if (meta.name) m.name = meta.name;
+            if (meta.index != null) m.index = meta.index;
+            if (meta.finishReason) m.finishReason = meta.finishReason;
+            detailParts.push(`tool=${JSON.stringify(m)}`);
+        }
+        // Invariant: a completion/finish signal was observed for this tool call
+        // (finish_reason present, or a per-call/response "done" event fired), so
+        // the arguments are NOT mid-stream-truncated — they are complete but
+        // malformed. Return an invalid-args MARKER (not a throw) so the
+        // dispatch loop feeds the parse error back to the model as a
+        // tool_result and the model self-corrects in the same turn. Only an
+        // unfinished stream (no finishReason) stays the retryable truncation
+        // case — that transient behavior is deliberately preserved.
+        if (meta?.finishReason) {
+            return makeInvalidToolArgsMarker(text, err instanceof Error ? err.message : String(err));
+        }
+        throw truncatedCompatStreamError(label, detailParts.join(' '));
+    }
+}