@pellux/goodvibes-sdk 0.18.14 → 0.18.16

package/dist/_internal/platform/providers/synthetic.js

@@ -0,0 +1,418 @@
+import { ProviderError, isRateLimitOrQuotaError } from '@pellux/goodvibes-sdk/platform/types/errors';
+import { logger } from '@pellux/goodvibes-sdk/platform/utils/logger';
+import { compositeScore } from '@pellux/goodvibes-sdk/platform/providers/model-benchmarks';
+import { emitModelFallback } from '../runtime/emitters/index.js';
+import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils/error-display';
+/**
+ * Returns true if the backend has at least one configured API key.
+ * Backends with empty envVars (or undefined) are always available (no key needed).
+ *
+ * Inlined here to avoid the circular import chain:
+ * synthetic.ts -> model-catalog.ts -> registry.ts -> synthetic.ts
+ */
+function hasKey(backend) {
+    const vars = backend.envVars;
+    if (!vars || vars.length === 0)
+        return true;
+    return vars.some(v => {
+        const val = process.env[v];
+        return typeof val === 'string' && val.length > 0;
+    });
+}
+/**
+ * Returns backend count metadata for a synthetic model ID.
+ * Used by the model picker to display provider availability.
+ *
+ * @returns Object with backendCount, keyedBackendCount, and tier, or null if not found.
+ */
+export function getSyntheticModelInfo(modelId, getCatalogModels) {
+    const catalog = [...getCatalogModels()];
+    const model = catalog.find(m => m.id === modelId);
+    if (!model)
+        return null;
+    return {
+        backendCount: model.backendCount,
+        keyedBackendCount: model.keyedBackendCount,
+        tier: model.tier,
+    };
+}
+// --- Backend selection ---
+/**
+ * Build a filtered and sorted backend list for a given synthetic model ID.
+ *
+ * Filtering rules:
+ * - Only backends matching the canonical model's tier (tier-isolated failover)
+ * - Only backends where the user has a configured API key (key-aware)
+ *
+ * Sort order: contextWindow descending → maxOutputTokens descending.
+ *
+ * Returns null if the model is not found in the catalog.
+ * Returns an empty array if the model exists but no backends have keys.
+ */
+function buildBackendList(syntheticId, getCatalogModels) {
+    const catalog = [...getCatalogModels()];
+    const canonical = catalog.find(m => m.id === syntheticId);
+    if (!canonical)
+        return null;
+    // Key-aware filtering: skip backends without configured keys
+    const keyed = canonical.backends.filter(hasKey);
+    // Sort: context desc → maxOutput desc
+    const sorted = keyed.slice().sort((a, b) => {
+        const ctxDiff = (b.contextWindow ?? 0) - (a.contextWindow ?? 0);
+        if (ctxDiff !== 0)
+            return ctxDiff;
+        return (b.maxOutputTokens ?? 0) - (a.maxOutputTokens ?? 0);
+    });
+    return { backends: sorted, canonical };
+}
+function bestCompositeScoreForModelWithLookup(model, getBenchmarks) {
+    let best = -1;
+    for (const b of model.backends) {
+        const entry = getBenchmarks(b.modelId);
+        if (entry) {
+            const score = compositeScore(entry.benchmarks);
+            if (score !== null && score > best)
+                best = score;
+        }
+    }
+    return best;
+}
+/**
+ * Resolve 'best-free' to the canonical ID of the highest composite-scored
+ * free model for which the user has at least one backend key configured.
+ *
+ * Returns null if no free models have keys or benchmark data.
+ */
+function resolveBestFree(getCatalogModels, getBenchmarks) {
+    const catalog = [...getCatalogModels()];
+    const freeModels = catalog.filter(m => m.tier === 'free');
+    let bestId = null;
+    let bestScore = -Infinity;
+    for (const model of freeModels) {
+        // Check if any backend for this model has a key
+        const hasAnyKey = model.backends.some(hasKey);
+        if (!hasAnyKey)
+            continue;
+        const effectiveScore = bestCompositeScoreForModelWithLookup(model, getBenchmarks);
+        if (effectiveScore > bestScore) {
+            bestScore = effectiveScore;
+            bestId = model.id;
+        }
+    }
+    return bestId;
+}
+/**
+ * Resolve the next-best free model by benchmark score, excluding models in `excludeIds`.
+ * Returns the canonical model ID or null if no alternatives exist.
+ */
+function resolveNextBestFree(excludeIds, getCatalogModels, getBenchmarks) {
+    const catalog = [...getCatalogModels()];
+    const freeModels = catalog.filter(m => m.tier === 'free' && !excludeIds.has(m.id));
+    let bestId = null;
+    let bestScore = -Infinity;
+    for (const model of freeModels) {
+        const hasAnyKey = model.backends.some(hasKey);
+        if (!hasAnyKey)
+            continue;
+        const effectiveScore = bestCompositeScoreForModelWithLookup(model, getBenchmarks);
+        if (effectiveScore > bestScore) {
+            bestScore = effectiveScore;
+            bestId = model.id;
+        }
+    }
+    return bestId;
+}
+// --- Default cooldown ---
+const DEFAULT_COOLDOWN_MS = 60_000;
+/** Short cooldown applied to a backend that returns a transient/server error (5xx, network, timeout). */
+const TRANSIENT_COOLDOWN_MS = 5_000;
+/**
+ * Maximum duration to transparently wait for a cooling-down backend before
+ * surfacing a 429 error to the caller. Waits of up to 2 minutes are hidden;
+ * longer cooldowns are escalated immediately.
+ */
+const MAX_AUTO_WAIT_MS = 120_000;
+/** Buffer added to the computed wait time to absorb clock skew and scheduling jitter. */
+const COOLDOWN_BUFFER_MS = 100;
+// --- SyntheticProvider ---
+export class SyntheticProvider {
+    name = 'synthetic';
+    getCatalogModels;
+    getBenchmarks;
+    runtimeBus;
+    /** Returns a live snapshot of canonical model IDs each time it is accessed. */
+    get models() {
+        return [
+            ...this.getCatalogModels().map(m => m.id),
+            'best-free',
+        ];
+    }
+    // Track cooldowns: syntheticModelId -> array of expiresAt timestamps indexed by resolved backend position
+    cooldowns = new Map();
+    // Track active backend index per resolved model ID
+    activeBackend = new Map();
+    resolveProvider;
+    constructor(options) {
+        this.resolveProvider = options.resolveProvider;
+        this.getCatalogModels = options.getCatalogModels;
+        this.getBenchmarks = options.getBenchmarks;
+        this.runtimeBus = options.runtimeBus ?? null;
+    }
+    async chat(params) {
+        let syntheticId = params.model;
+        // Resolve 'best-free' alias
+        if (syntheticId === 'best-free') {
+            const resolved = resolveBestFree(this.getCatalogModels, this.getBenchmarks);
+            if (!resolved) {
+                throw new ProviderError('No API keys configured for any provider offering free models', {
+                    statusCode: 400,
+                    provider: this.name,
+                    operation: 'chat',
+                    phase: 'routing',
+                });
+            }
+            logger.debug(`[Synthetic] best-free resolved to: ${resolved}`);
+            syntheticId = resolved;
+        }
+        const result = buildBackendList(syntheticId, this.getCatalogModels);
+        if (!result) {
+            throw new ProviderError(`Unknown synthetic model: ${syntheticId}`, {
+                statusCode: 400,
+                provider: this.name,
+                operation: 'chat',
+                phase: 'routing',
+            });
+        }
+        const { backends, canonical } = result;
+        if (backends.length === 0) {
+            throw new ProviderError(`No API keys configured for any provider offering ${canonical.id}`, {
+                statusCode: 400,
+                provider: this.name,
+                operation: 'chat',
+                phase: 'routing',
+            });
+        }
+        const now = Date.now();
+        if (!this.cooldowns.has(syntheticId)) {
+            this.cooldowns.set(syntheticId, new Array(backends.length).fill(0));
+        }
+        // Resize cooldown array if backend count changed (catalog updated)
+        let cooldownArr = this.cooldowns.get(syntheticId);
+        if (cooldownArr.length !== backends.length) {
+            cooldownArr = new Array(backends.length).fill(0);
+            this.cooldowns.set(syntheticId, cooldownArr);
+        }
+        // Reset to preferred backend if its cooldown expired
+        if (cooldownArr[0] <= now) {
+            this.activeBackend.set(syntheticId, 0);
+        }
+        const startIndex = this.activeBackend.get(syntheticId) ?? 0;
+        const errors = [];
+        let shortestCooldown = Infinity;
+        // Try each backend in order, starting from active
+        for (let i = 0; i < backends.length; i++) {
+            const idx = (startIndex + i) % backends.length;
+            const backend = backends[idx];
+            // Skip if still in cooldown
+            if (cooldownArr[idx] > now) {
+                const remaining = cooldownArr[idx] - now;
+                if (remaining < shortestCooldown)
+                    shortestCooldown = remaining;
+                continue;
+            }
+            // Resolve provider
+            let provider;
+            try {
+                provider = this.resolveProvider(backend.providerName);
+            }
+            catch (err) {
+                logger.debug(`[Synthetic] Backend ${backend.providerName} not available: ${err}`);
+                continue;
+            }
+            // Attempt the call
+            // Note: if onDelta is set and a rate limit occurs mid-stream, partial content
+            // from this backend will already have been delivered to the caller. The next
+            // backend starts fresh, which may produce garbled output. In practice, rate
+            // limits reject before streaming begins (at the HTTP level), so this is
+            // unlikely to trigger.
+            try {
+                const response = await provider.chat({
+                    ...params,
+                    model: backend.modelId,
+                });
+                // Success — update active backend
+                this.activeBackend.set(syntheticId, idx);
+                logger.info(`[Synthetic] ${syntheticId} served by ${backend.providerName} (${backend.modelId})`);
+                return response;
+            }
+            catch (err) {
+                if (isRateLimitOrQuotaError(err)) {
+                    // Record cooldown
+                    const cooldownMs = (err instanceof ProviderError && err.retryAfterMs)
+                        ? err.retryAfterMs
+                        : DEFAULT_COOLDOWN_MS;
+                    cooldownArr[idx] = now + cooldownMs;
+                    this.cooldowns.set(syntheticId, cooldownArr);
+                    if (cooldownMs < shortestCooldown)
+                        shortestCooldown = cooldownMs;
+                    logger.info(`[Synthetic] ${backend.providerName} rate-limited for ${syntheticId}, cooldown ${Math.round(cooldownMs / 1000)}s`);
+                    errors.push({ backend, error: err });
+                    continue;
+                }
+                // 400 Bad Request — the request itself is malformed, no point trying other backends
+                const isBadRequest = err instanceof ProviderError
+                    && err.statusCode === 400;
+                if (isBadRequest) {
+                    throw err;
+                }
+                // Other client errors (401 auth, 403 billing/forbidden, 404 model not found, etc.)
+                // are provider-specific — failover to next backend with long cooldown
+                const isProviderClientError = err instanceof ProviderError
+                    && err.statusCode !== undefined
+                    && err.statusCode > 400
+                    && err.statusCode < 500;
+                if (isProviderClientError) {
+                    cooldownArr[idx] = now + DEFAULT_COOLDOWN_MS;
+                    this.cooldowns.set(syntheticId, cooldownArr);
+                    if (DEFAULT_COOLDOWN_MS < shortestCooldown)
+                        shortestCooldown = DEFAULT_COOLDOWN_MS;
+                    logger.info(`[Synthetic] ${backend.providerName} returned ${err.statusCode} for ${syntheticId}, trying next backend`);
+                    errors.push({ backend, error: err });
+                    continue;
+                }
+                // Transient/server error — short cooldown, failover to next backend
+                cooldownArr[idx] = now + TRANSIENT_COOLDOWN_MS;
+                this.cooldowns.set(syntheticId, cooldownArr);
+                if (TRANSIENT_COOLDOWN_MS < shortestCooldown)
+                    shortestCooldown = TRANSIENT_COOLDOWN_MS;
+                logger.debug(`[Synthetic] ${backend.providerName} failed for ${syntheticId}: ${summarizeError(err) ?? err}, trying next backend`);
+                errors.push({ backend, error: err });
+                continue;
+            }
+        }
+        // All backends exhausted — auto-wait if the shortest cooldown is within threshold
+        if (shortestCooldown !== Infinity && shortestCooldown <= MAX_AUTO_WAIT_MS) {
+            // Find the backend index with the shortest remaining cooldown
+            const nowForWait = Date.now();
+            let waitIdx = 0;
+            let minExpiry = Infinity;
+            for (let i = 0; i < cooldownArr.length; i++) {
+                if (cooldownArr[i] > nowForWait && cooldownArr[i] < minExpiry) {
+                    minExpiry = cooldownArr[i];
+                    waitIdx = i;
+                }
+            }
+            const waitBackend = backends[waitIdx];
+            const waitMs = minExpiry - nowForWait;
+            logger.debug(`[Synthetic] All backends cooling down for ${syntheticId}, auto-waiting ${Math.round(waitMs / 1000)}s for ${waitBackend.providerName}…`);
+            // Wait with AbortSignal support
+            await new Promise((resolve, reject) => {
+                const onAbort = () => {
+                    clearTimeout(timer);
+                    reject(new ProviderError('Request aborted during cooldown wait', {
+                        statusCode: 499,
+                        provider: this.name,
+                        operation: 'chat',
+                        phase: 'cooldown',
+                    }));
+                };
+                const timer = setTimeout(() => {
+                    if (params.signal)
+                        params.signal.removeEventListener('abort', onAbort);
+                    resolve();
+                }, waitMs + COOLDOWN_BUFFER_MS);
+                if (params.signal) {
+                    if (params.signal.aborted) {
+                        clearTimeout(timer);
+                        reject(new ProviderError('Request aborted during cooldown wait', {
+                            statusCode: 499,
+                            provider: this.name,
+                            operation: 'chat',
+                            phase: 'cooldown',
+                        }));
+                        return;
+                    }
+                    params.signal.addEventListener('abort', onAbort, { once: true });
+                }
+            });
+            // Single retry attempt on the backend that just came off cooldown
+            try {
+                const waitProvider = this.resolveProvider(waitBackend.providerName);
+                const response = await waitProvider.chat({
+                    ...params,
+                    model: waitBackend.modelId,
+                });
+                this.activeBackend.set(syntheticId, waitIdx);
+                logger.info(`[Synthetic] ${syntheticId} served by ${waitBackend.providerName} (${waitBackend.modelId}) after auto-wait`);
+                return response;
+            }
+            catch (retryErr) {
+                // Retry failed — fall through to throw below
+                logger.debug(`[Synthetic] Auto-wait retry failed for ${syntheticId} via ${waitBackend.providerName}: ${retryErr}`);
+            }
+        }
+        // All backends exhausted (or cooldown exceeded threshold, or retry failed)
+        const cooldownSec = shortestCooldown === Infinity ? '?' : Math.round(shortestCooldown / 1000);
+        // Cross-model failover for free tier only
+        if (canonical.tier === 'free') {
+            const tried = new Set([syntheticId]);
+            let fallbackId = resolveNextBestFree(tried, this.getCatalogModels, this.getBenchmarks);
+            while (fallbackId) {
+                tried.add(fallbackId);
+                const fallbackResult = buildBackendList(fallbackId, this.getCatalogModels);
+                if (!fallbackResult || fallbackResult.backends.length === 0) {
+                    fallbackId = resolveNextBestFree(tried, this.getCatalogModels, this.getBenchmarks);
+                    continue;
+                }
+                for (const backend of fallbackResult.backends) {
+                    try {
+                        const provider = this.resolveProvider(backend.providerName);
+                        const response = await provider.chat({
+                            ...params,
+                            model: backend.modelId,
+                        });
+                        this.activeBackend.set(fallbackId, 0);
+                        logger.info(`[Synthetic] ${syntheticId} exhausted, fell back to ${fallbackId} via ${backend.providerName}`);
+                        if (this.runtimeBus) {
+                            try {
+                                emitModelFallback(this.runtimeBus, {
+                                    sessionId: 'system',
+                                    traceId: `synthetic:fallback:${syntheticId}:${fallbackId}`,
+                                    source: 'synthetic-provider',
+                                }, {
+                                    from: syntheticId,
+                                    to: fallbackId,
+                                    provider: backend.providerName,
+                                });
+                            }
+                            catch (e) {
+                                logger.debug('[Synthetic] runtime bus emit failed', { error: summarizeError(e) });
+                            }
+                        }
+                        return response;
+                    }
+                    catch (err) {
+                        logger.debug(`[Synthetic] Fallback ${fallbackId} via ${backend.providerName} failed: ${summarizeError(err)}`);
+                        continue;
+                    }
+                }
+                // All backends for this fallback exhausted, try next model
+                fallbackId = resolveNextBestFree(tried, this.getCatalogModels, this.getBenchmarks);
+            }
+            // All free models exhausted
+            throw new ProviderError(`All free models exhausted. No alternatives available. Last tried: ${[...tried].join(', ')}`, {
+                statusCode: 429,
+                provider: this.name,
+                operation: 'chat',
+                phase: 'routing',
+            });
+        }
+        throw new ProviderError(`All backends for ${syntheticId} exhausted. Shortest cooldown expires in ${cooldownSec}s. ` +
+            `Tried: ${errors.map(e => `${e.backend.providerName} (${e.error.message})`).join(', ')}`, {
+            statusCode: 429,
+            provider: this.name,
+            operation: 'chat',
+            phase: 'routing',
+        });
+    }
+}

package/dist/_internal/platform/providers/tier-prompts.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Tier-based system prompt supplements.
+ *
+ * Model capability tiers drive how much extra guidance is injected into
+ * the system prompt.  All features remain available regardless of tier;
+ * only the verbosity of the guidance changes.
+ */
+import type { ModelTier } from './registry.js';
+export type { ModelTier };
+/**
+ * Derive the model tier from a model's context window size.
+ *
+ * - small  (<32K)     → 'free'     (needs most guidance)
+ * - medium (32K–128K) → 'standard' (brief reminders)
+ * - large  (>128K)    → 'premium'  (no extra guidance needed)
+ *
+ * This is used instead of the static ModelDefinition.tier field so that
+ * tier-prompt selection is driven by actual model capabilities.
+ */
+export declare function getTierForContextWindow(contextWindow: number): ModelTier;
+/**
+ * Returns supplemental system prompt content based on the model's capability
+ * tier.  The returned string is appended to the base system prompt before
+ * each LLM call.
+ *
+ * - free    — explicit tool-call examples, multi-agent reminders, structured
+ *             output enforcement (~300 tokens)
+ * - standard — brief reminders about tool usage and plan adherence (~80 tokens)
+ * - premium  — empty; capable models need no extra hand-holding
+ */
+export declare function getTierPromptSupplement(tier: ModelTier): string;
+//# sourceMappingURL=tier-prompts.d.ts.map

package/dist/_internal/platform/providers/tier-prompts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tier-prompts.d.ts","sourceRoot":"","sources":["../../../../src/_internal/platform/providers/tier-prompts.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAC/C,YAAY,EAAE,SAAS,EAAE,CAAC;AAE1B;;;;;;;;;GASG;AACH,wBAAgB,uBAAuB,CAAC,aAAa,EAAE,MAAM,GAAG,SAAS,CAIxE;AAED;;;;;;;;;GASG;AACH,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,SAAS,GAAG,MAAM,CAW/D"}

package/dist/_internal/platform/providers/tier-prompts.js

@@ -0,0 +1,78 @@
+/**
+ * Tier-based system prompt supplements.
+ *
+ * Model capability tiers drive how much extra guidance is injected into
+ * the system prompt.  All features remain available regardless of tier;
+ * only the verbosity of the guidance changes.
+ */
+/**
+ * Derive the model tier from a model's context window size.
+ *
+ * - small  (<32K)     → 'free'     (needs most guidance)
+ * - medium (32K–128K) → 'standard' (brief reminders)
+ * - large  (>128K)    → 'premium'  (no extra guidance needed)
+ *
+ * This is used instead of the static ModelDefinition.tier field so that
+ * tier-prompt selection is driven by actual model capabilities.
+ */
+export function getTierForContextWindow(contextWindow) {
+    if (contextWindow > 128_000)
+        return 'premium';
+    if (contextWindow >= 32_000)
+        return 'standard';
+    return 'free';
+}
+/**
+ * Returns supplemental system prompt content based on the model's capability
+ * tier.  The returned string is appended to the base system prompt before
+ * each LLM call.
+ *
+ * - free    — explicit tool-call examples, multi-agent reminders, structured
+ *             output enforcement (~300 tokens)
+ * - standard — brief reminders about tool usage and plan adherence (~80 tokens)
+ * - premium  — empty; capable models need no extra hand-holding
+ */
+export function getTierPromptSupplement(tier) {
+    switch (tier) {
+        case 'free':
+            return FREE_SUPPLEMENT;
+        case 'standard':
+            return STANDARD_SUPPLEMENT;
+        case 'premium':
+            return '';
+        case 'subscription':
+            return '';
+    }
+}
+// ---------------------------------------------------------------------------
+// Supplement text
+// ---------------------------------------------------------------------------
+const FREE_SUPPLEMENT = `## Agent Guidance
+
+You are operating in a multi-agent system. Follow these rules carefully:
+
+**Tool calls — required format:**
+Every tool call must include ALL required parameters. Missing parameters cause
+silent failures. When in doubt, check the tool's schema before calling it.
+
+Example — correct agent spawn:
+\`\`\`json
+{ "name": "agent", "input": { "task": "<task>", "mode": "engineer" } }
+\`\`\`
+
+**Multi-agent workflows:**
+When a plan requires multiple parallel agents, spawn ALL of them before
+waiting for results — do not spawn one, wait, then spawn the next. Parallel
+spawns run concurrently and complete faster.
+
+**Structured output:**
+Your final message MUST end with the required JSON completion block. Omitting
+it causes the orchestrator to treat your run as failed.
+
+**Plan adherence:**
+Complete the full plan. Do not stop after the first step and ask for
+confirmation — there is no human watching. Make the best choice and continue.`;
+const STANDARD_SUPPLEMENT = `## Reminders
+- Include all required parameters in every tool call.
+- When spawning agents, use the correct \`mode\` parameter.
+- Complete your full plan before reporting results.`;

package/dist/_internal/platform/providers/tool-formats.d.ts

@@ -0,0 +1,137 @@
+import type { ToolDefinition, ToolCall } from '@pellux/goodvibes-sdk/platform/types/tools';
+import type { ProviderMessage } from './interface.js';
+export interface OpenAITool {
+    type: 'function';
+    function: {
+        name: string;
+        description: string;
+        parameters: Record<string, unknown>;
+    };
+}
+export interface OpenAIToolCall {
+    id: string;
+    type: 'function';
+    function: {
+        name: string;
+        arguments: string;
+    };
+}
+export type OpenAIContentPart = {
+    type: 'text';
+    text: string;
+} | {
+    type: 'image_url';
+    image_url: {
+        url: string;
+    };
+};
+export interface OpenAIMessage {
+    role: 'system' | 'user' | 'assistant' | 'tool';
+    content: string | OpenAIContentPart[] | null;
+    tool_calls?: OpenAIToolCall[];
+    tool_call_id?: string;
+}
+/** Convert internal ToolDefinitions to OpenAI tools array. */
+export declare function toOpenAITools(tools: ToolDefinition[]): OpenAITool[];
+/** Parse OpenAI tool_calls from a response into internal ToolCall[]. */
+export declare function fromOpenAIToolCalls(calls: OpenAIToolCall[]): ToolCall[];
+/** Convert internal ProviderMessages to OpenAI message array. */
+export declare function toOpenAIMessages(messages: ProviderMessage[], systemPrompt?: string): OpenAIMessage[];
+export interface AnthropicTool {
+    name: string;
+    description: string;
+    input_schema: Record<string, unknown>;
+}
+export type AnthropicContentBlock = {
+    type: 'text';
+    text: string;
+} | {
+    type: 'image';
+    source: {
+        type: 'base64';
+        media_type: 'image/png' | 'image/jpeg' | 'image/gif' | 'image/webp';
+        data: string;
+    };
+} | {
+    type: 'tool_use';
+    id: string;
+    name: string;
+    input: Record<string, unknown>;
+} | {
+    type: 'tool_result';
+    tool_use_id: string;
+    content: string;
+};
+export interface AnthropicMessage {
+    role: 'user' | 'assistant';
+    content: string | AnthropicContentBlock[];
+}
+/** Convert internal ToolDefinitions to Anthropic tools array. */
+export declare function toAnthropicTools(tools: ToolDefinition[]): AnthropicTool[];
+/** Parse Anthropic response content blocks into text + ToolCall[]. */
+export declare function fromAnthropicContent(content: AnthropicContentBlock[]): {
+    text: string;
+    toolCalls: ToolCall[];
+};
+/** Convert internal ProviderMessages to Anthropic message array. */
+export declare function toAnthropicMessages(messages: ProviderMessage[]): AnthropicMessage[];
+export interface GeminiFunctionDeclaration {
+    name: string;
+    description: string;
+    parameters: Record<string, unknown>;
+}
+export interface GeminiPart {
+    text?: string;
+    inlineData?: {
+        mimeType: string;
+        data: string;
+    };
+    functionCall?: {
+        name: string;
+        args: Record<string, unknown>;
+    };
+    functionResponse?: {
+        name: string;
+        response: {
+            content: string;
+        };
+    };
+}
+export interface GeminiContent {
+    role: 'user' | 'model';
+    parts: GeminiPart[];
+}
+/** Convert internal ToolDefinitions to Gemini functionDeclarations. */
+export declare function toGeminiFunctionDeclarations(tools: ToolDefinition[]): GeminiFunctionDeclaration[];
+/** Parse Gemini response parts into text + ToolCall[]. */
+export declare function fromGeminiParts(parts: GeminiPart[]): {
+    text: string;
+    toolCalls: ToolCall[];
+};
+/** Convert internal ProviderMessages to Gemini contents array. */
+export declare function toGeminiContents(messages: ProviderMessage[], systemPrompt?: string): {
+    contents: GeminiContent[];
+    systemInstruction?: {
+        parts: GeminiPart[];
+    };
+};
+/**
+ * Extracts tool calls from raw text content for models (e.g. kimi-k2-thinking
+ * via ollama-cloud) that emit tool calls as text tokens instead of using the
+ * OpenAI function-calling wire format.
+ *
+ * Supports two delimiter formats (both emitted by kimi variants):
+ *   Without underscores: <|toolcallbegin|>functions.TOOLNAME:INDEX<|toolcallargumentbegin|>JSON_ARGS<|toolcallend|>
+ *   With underscores:    <|tool_call_begin|>functions.TOOLNAME:INDEX<|tool_call_argument_begin|>JSON_ARGS<|tool_call_end|>
+ *
+ * A trailing <|tool_calls_section_end|> or <|toolcallssectionend|> is also
+ * stripped from the cleaned content.
+ *
+ * @returns Extracted ToolCall array and the content with all tool-call tokens
+ * removed (trimmed). Returns empty array when no text-based calls are found.
+ */
+export declare function extractTextToolCalls(content: string): {
+    toolCalls: ToolCall[];
+    cleanedContent: string;
+};
+//# sourceMappingURL=tool-formats.d.ts.map

package/dist/_internal/platform/providers/tool-formats.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-formats.d.ts","sourceRoot":"","sources":["../../../../src/_internal/platform/providers/tool-formats.ts"],"names":[],"mappings":"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"}