@crewx/sdk 0.8.0-rc.73 → 0.8.0-rc.75

package/dist/provider/bridge.js

@@ -0,0 +1,380 @@
+"use strict";
+/**
+ * Provider bridge: creates a runtime that can invoke AI providers.
+ *
+ * Supports a registry pattern — built-in cli/* providers are registered by default,
+ * and additional namespaces (e.g. api/*, webllm/*) can be added via registerProviderFactory().
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClientToolCallRequiredError = exports.ProviderError = void 0;
+exports.parseStreamJsonOutput = parseStreamJsonOutput;
+exports.parseResultEventUsage = parseResultEventUsage;
+exports.registerProviderFactory = registerProviderFactory;
+exports.createProvider = createProvider;
+const child_process_1 = require("child_process");
+const parse_usage_js_1 = require("./parse-usage.js");
+function parseStreamJsonOutput(raw) {
+    const lines = raw.split('\n').filter(l => l.trim());
+    const assistantTexts = [];
+    const geminiDeltaTokens = [];
+    const copilotTexts = [];
+    const codexTexts = [];
+    const opencodeTexts = [];
+    let resultText = null;
+    for (const line of lines) {
+        try {
+            const parsed = JSON.parse(line);
+            // Claude format: { type: 'assistant', message: { content: [...] } }
+            if (parsed.type === 'assistant' && Array.isArray(parsed.message?.content)) {
+                for (const block of parsed.message.content) {
+                    if (block.type === 'text' && typeof block.text === 'string' && block.text.trim()) {
+                        assistantTexts.push(block.text.trim());
+                    }
+                }
+            }
+            // Gemini format: { type: 'message', role: 'assistant', delta: true, content: '...' }
+            if (parsed.type === 'message' &&
+                parsed.role === 'assistant' &&
+                parsed.delta === true &&
+                typeof parsed.content === 'string') {
+                geminiDeltaTokens.push(parsed.content);
+            }
+            // Copilot format: { type: 'assistant.message', data: { content: '...' } }
+            if (parsed.type === 'assistant.message' &&
+                typeof parsed.data?.content === 'string') {
+                const content = parsed.data.content;
+                if (content.trim())
+                    copilotTexts.push(content.trim());
+            }
+            // Codex format: { type: 'item.completed', item: { type: 'message'|'agent_message', text: '...' } }
+            // codex-specific: both 'message' and 'agent_message' item types are accepted
+            if (parsed.type === 'item.completed' &&
+                (parsed.item?.type === 'message' || parsed.item?.type === 'agent_message') &&
+                typeof parsed.item?.text === 'string') {
+                const text = parsed.item.text;
+                if (text.trim())
+                    codexTexts.push(text.trim());
+            }
+            // OpenCode format: { type: 'text', part: { text: '...' } }
+            if (parsed.type === 'text' && typeof parsed.part?.text === 'string') {
+                const text = parsed.part.text;
+                if (text.trim())
+                    opencodeTexts.push(text.trim());
+            }
+            if (parsed.type === 'result' && typeof parsed.result === 'string') {
+                resultText = parsed.result;
+            }
+        }
+        catch {
+            // Not valid JSON line — skip
+        }
+    }
+    if (assistantTexts.length > 0)
+        return assistantTexts.join('\n\n');
+    if (geminiDeltaTokens.length > 0)
+        return geminiDeltaTokens.join('');
+    if (copilotTexts.length > 0)
+        return copilotTexts.join('\n\n');
+    if (codexTexts.length > 0)
+        return codexTexts.join('\n\n');
+    if (opencodeTexts.length > 0)
+        return opencodeTexts.join('');
+    if (resultText)
+        return resultText;
+    return raw.trim();
+}
+function parseResultEventUsage(raw) {
+    const parsed = (0, parse_usage_js_1.parseUsage)(raw);
+    if (!parsed)
+        return null;
+    return {
+        inputTokens: parsed.inputTokens,
+        outputTokens: parsed.outputTokens,
+        cachedInputTokens: parsed.cachedInputTokens,
+        costUsd: 0,
+    };
+}
+class ProviderError extends Error {
+    providerStr;
+    constructor(message, providerStr) {
+        super(message);
+        this.providerStr = providerStr;
+        this.name = 'ProviderError';
+    }
+}
+exports.ProviderError = ProviderError;
+/**
+ * Thrown by VercelProviderRuntime when generateText() encounters a tool without
+ * an execute function (client tool). The caller should return requires_action
+ * to the client, collect the tool result, and call continueWithToolResults().
+ */
+class ClientToolCallRequiredError extends Error {
+    toolCall;
+    continuationState;
+    name = 'ClientToolCallRequiredError';
+    constructor(toolCall, continuationState) {
+        super(`Client tool call required: ${toolCall.toolName}`);
+        this.toolCall = toolCall;
+        this.continuationState = continuationState;
+    }
+}
+exports.ClientToolCallRequiredError = ClientToolCallRequiredError;
+// ── Provider factory registry ───────────────────────────────────────────────
+const _providerFactories = new Map();
+/**
+ * Register a provider factory for a given namespace.
+ *
+ * @example
+ * // Register an API-based provider namespace
+ * registerProviderFactory('api', (id, providerStr) => new MyApiProvider(id));
+ *
+ * // Now createProvider('api/claude') works
+ * const provider = createProvider('api/claude');
+ */
+function registerProviderFactory(namespace, factory) {
+    _providerFactories.set(namespace, factory);
+}
+// CLI command mapping for each supported provider id
+const CLI_COMMANDS = {
+    claude: 'claude',
+    gemini: 'gemini',
+    copilot: 'copilot', // GitHub Copilot CLI (standalone binary)
+    codex: 'codex',
+    opencode: 'opencode', // OpenCode CLI (--format json stream)
+};
+/**
+ * Create a provider runtime for the given provider string.
+ *
+ * Looks up the namespace in the provider registry first.
+ * Falls back to built-in cli/* providers for backward compatibility.
+ *
+ * @param providerStr - Provider string in namespace/id format (e.g., 'cli/claude', 'api/claude')
+ * @throws ProviderError for unknown or unsupported providers
+ */
+function createProvider(providerStr) {
+    const parts = providerStr.split('/');
+    if (parts.length !== 2) {
+        throw new ProviderError(`Invalid provider format: "${providerStr}". Expected namespace/id (e.g., cli/claude)`, providerStr);
+    }
+    const [namespace, id] = parts;
+    // Check registry first (covers both user-registered and built-in cli namespace)
+    const factory = _providerFactories.get(namespace);
+    if (factory) {
+        return factory(id, providerStr);
+    }
+    // Built-in cli/* fallback (for backward compatibility when cli factory is not explicitly registered)
+    if (namespace === 'cli') {
+        const cliCommand = CLI_COMMANDS[id];
+        if (!cliCommand) {
+            throw new ProviderError(`Unknown CLI provider id: "${id}". Supported: ${Object.keys(CLI_COMMANDS).join(', ')}`, providerStr);
+        }
+        return new CliProviderRuntime(id, cliCommand, providerStr);
+    }
+    throw new ProviderError(`Unsupported provider namespace: "${namespace}". Register a factory with registerProviderFactory('${namespace}', factory).`, providerStr);
+}
+/**
+ * Provider runtime that spawns a CLI process and collects its output.
+ */
+class CliProviderRuntime {
+    providerId;
+    cliCommand;
+    providerStr;
+    constructor(providerId, cliCommand, providerStr) {
+        this.providerId = providerId;
+        this.cliCommand = cliCommand;
+        this.providerStr = providerStr;
+    }
+    async execute(message, options) {
+        const { args, stdinMessage } = this.buildArgs(message, options, true);
+        options?.onCommand?.(`${this.cliCommand} ${args.join(' ')}`);
+        return this.runProcess(args, options, stdinMessage);
+    }
+    async query(message, options) {
+        const { args, stdinMessage } = this.buildArgs(message, options);
+        options?.onCommand?.(`${this.cliCommand} ${args.join(' ')}`);
+        return this.runProcess(args, options, stdinMessage);
+    }
+    runProcess(args, options, stdinMessage) {
+        return new Promise((resolve, reject) => {
+            const proc = (0, child_process_1.spawn)(this.cliCommand, args, {
+                env: { ...process.env, ...(options?.env ?? {}) },
+                cwd: options?.cwd,
+                stdio: ['pipe', 'pipe', 'pipe'],
+            });
+            // Write message to stdin for providers that read prompt from stdin (e.g. codex)
+            // Always close stdin afterwards — some CLIs (e.g. opencode) hang waiting for
+            // input otherwise, even when the prompt was passed via argv.
+            if (stdinMessage !== undefined) {
+                proc.stdin.write(stdinMessage);
+            }
+            proc.stdin.end();
+            // Report child PID immediately after spawn
+            if (proc.pid !== undefined) {
+                options?.onPid?.(proc.pid);
+            }
+            let stdout = '';
+            let stderr = '';
+            let stdoutBuf = '';
+            let stderrBuf = '';
+            proc.stdout.on('data', (chunk) => {
+                const str = chunk.toString();
+                stdout += str;
+                stdoutBuf += str;
+                const lines = stdoutBuf.split('\n');
+                stdoutBuf = lines.pop() ?? '';
+                for (const line of lines) {
+                    if (line.trim())
+                        options?.onOutput?.(line, 'stdout');
+                }
+            });
+            proc.stderr.on('data', (chunk) => {
+                const str = chunk.toString();
+                stderr += str;
+                stderrBuf += str;
+                const lines = stderrBuf.split('\n');
+                stderrBuf = lines.pop() ?? '';
+                for (const line of lines) {
+                    if (line.trim())
+                        options?.onOutput?.(line, 'stderr');
+                }
+            });
+            proc.on('error', (err) => {
+                if (err.code === 'ENOENT') {
+                    reject(new ProviderError(`CLI command "${this.cliCommand}" not found. Is ${this.providerStr} installed?`, this.providerStr));
+                }
+                else {
+                    reject(new ProviderError(`Spawn error: ${err.message}`, this.providerStr));
+                }
+            });
+            proc.on('close', (code) => {
+                // Flush any residual buffered content (no trailing newline)
+                if (stdoutBuf.trim())
+                    options?.onOutput?.(stdoutBuf, 'stdout');
+                if (stderrBuf.trim())
+                    options?.onOutput?.(stderrBuf, 'stderr');
+                const exitCode = code ?? 0;
+                options?.onExitCode?.(exitCode);
+                if (code !== 0) {
+                    reject(new ProviderError(`Process exited with code ${code}: ${stderr.slice(0, 500)}`, this.providerStr));
+                    return;
+                }
+                // Extract usage and model from stream-json result event before resolving
+                const { usage, model } = this.parseResultEvent(stdout);
+                if (usage && options?.onUsage) {
+                    options.onUsage(usage);
+                }
+                // OpenCode stream doesn't emit model info in events; fall back to configured model
+                const effectiveModel = model ?? (this.providerId === 'opencode' ? (options?.model ?? null) : null);
+                if (effectiveModel && options?.onModel) {
+                    options.onModel(effectiveModel);
+                }
+                const parsed = this.parseOutput(stdout);
+                resolve(parsed);
+            });
+        });
+    }
+    buildArgs(message, options, isExecute = false) {
+        // HOTFIX: compose systemPrompt into the outgoing message for all CLI providers.
+        // CLI providers don't have a common --system-prompt flag, and agent-rendered
+        // prompts (persona, rules, inline.prompt, builtin_tools, skills) were being
+        // dropped entirely before this fix. Provider-native system-prompt flags
+        // (e.g. claude --append-system-prompt) should be adopted per-provider later
+        // for proper system/user separation + prompt caching.
+        const effectiveMessage = options?.systemPrompt
+            ? `${options.systemPrompt}\n\n---\n\n${message}`
+            : message;
+        // Copilot uses standalone `copilot` binary with prompt via stdin
+        // (matching pre-refactoring CopilotProvider behavior)
+        if (this.providerId === 'copilot') {
+            const args = options?.additionalArgs ? [...options.additionalArgs] : [];
+            if (options?.model)
+                args.push('--model', options.model);
+            return { args, stdinMessage: effectiveMessage };
+        }
+        // OpenCode: prompt is a positional arg appended last; --format json is system-forced.
+        // Security flags (e.g. --dangerously-skip-permissions) come from options.additionalArgs
+        // so operators can control them via crewx.yaml.
+        if (this.providerId === 'opencode') {
+            const additionalArgs = options?.additionalArgs;
+            const args = additionalArgs !== undefined ? [...additionalArgs] : ['run'];
+            // System guarantee: --format json must be present for stream-json parsing
+            if (!args.includes('--format')) {
+                args.push('--format', 'json');
+            }
+            if (options?.model)
+                args.push('--model', options.model);
+            args.push(effectiveMessage);
+            return { args };
+        }
+        // If agent config provides explicit CLI options, use them directly
+        if (options?.additionalArgs !== undefined) {
+            const args = [...options.additionalArgs];
+            const pIdx = args.indexOf('-p');
+            if (pIdx !== -1) {
+                // -p flag present: insert message as its value
+                args.splice(pIdx + 1, 0, effectiveMessage);
+                if (options.model)
+                    args.push('--model', options.model);
+                return { args };
+            }
+            else {
+                // No -p flag: provider reads prompt from stdin (e.g. codex)
+                // codex-specific safety net: ensure a JSON output flag is present.
+                // Accept both --json (older) and --experimental-json (newer) as equivalent.
+                if (this.providerId === 'codex' && !args.includes('--json') && !args.includes('--experimental-json')) {
+                    args.push('--json');
+                }
+                if (options.model)
+                    args.push('--model', options.model);
+                return { args, stdinMessage: effectiveMessage };
+            }
+        }
+        // Default fallback: claude/gemini stream-json format
+        const args = ['-p', effectiveMessage, '--output-format', 'stream-json', '--verbose'];
+        if (isExecute) {
+            args.push('--dangerously-skip-permissions');
+        }
+        if (options?.model) {
+            args.push('--model', options.model);
+        }
+        return { args };
+    }
+    parseOutput(raw) {
+        return parseStreamJsonOutput(raw);
+    }
+    /**
+     * Extract token usage, cost, and model from the stream-json result event.
+     * Claude CLI emits: { type: "result", usage: {...}, total_cost_usd: ..., modelUsage: {...} }
+     * OpenCode CLI emits: { type: "step_finish", part: { tokens: { input, output, cache: { read, write } }, cost: 0 } }
+     */
+    parseResultEvent(raw) {
+        const baseUsage = parseResultEventUsage(raw);
+        const lines = raw.split('\n');
+        for (const line of lines) {
+            if (!line.trim())
+                continue;
+            try {
+                const parsed = JSON.parse(line);
+                if (parsed.type === 'result') {
+                    const usageRaw = parsed.usage;
+                    const usage = usageRaw
+                        ? {
+                            inputTokens: Number(usageRaw['input_tokens'] ?? 0),
+                            outputTokens: Number(usageRaw['output_tokens'] ?? 0),
+                            cachedInputTokens: Number(usageRaw['cache_read_input_tokens'] ?? 0),
+                            costUsd: Number(parsed['total_cost_usd'] ?? 0),
+                        }
+                        : baseUsage;
+                    const modelUsage = parsed.modelUsage;
+                    const model = modelUsage ? Object.keys(modelUsage)[0] ?? null : null;
+                    return { usage, model };
+                }
+            }
+            catch {
+                // Not JSON — skip
+            }
+        }
+        return { usage: baseUsage, model: null };
+    }
+}
+//# sourceMappingURL=bridge.js.map

package/dist/provider/mastra-runtime.d.ts

@@ -0,0 +1,45 @@
+/**
+ * MastraProviderRuntime — API 프로바이더를 위한 ProviderRuntime 구현.
+ *
+ * Mastra Agent를 래핑하여 tool calling loop를 자동 처리한다.
+ * Vercel AI SDK 기반 모델 인스턴스를 생성하여 OpenRouter, OpenAI, Anthropic, Google 지원.
+ */
+import type { ProviderRuntime, ProviderQueryOptions } from './bridge';
+export interface MastraProviderConfig {
+    /** Provider string (e.g. 'api/openrouter', 'api/anthropic'). */
+    provider: string;
+    /** Model identifier (e.g. 'anthropic/claude-sonnet-4-20250514'). */
+    model: string;
+    /** API key — falls back to environment variable if not set. */
+    apiKey?: string;
+    /** Custom base URL (e.g. OpenRouter endpoint). */
+    baseURL?: string;
+    /** Sampling temperature. */
+    temperature?: number;
+    /** Max output tokens. */
+    maxTokens?: number;
+    /** Default max steps for tool loop. */
+    maxSteps?: number;
+}
+export declare class MastraProviderRuntime implements ProviderRuntime {
+    private config;
+    constructor(config: MastraProviderConfig);
+    query(message: string, options?: ProviderQueryOptions): Promise<string>;
+    execute(message: string, options?: ProviderQueryOptions): Promise<string>;
+    private _run;
+    /**
+     * CrewX ToolDefinition[] → Mastra tool Record 변환.
+     * JSON Schema → Zod 간이 변환 포함.
+     */
+    private convertTools;
+    /**
+     * JSON Schema → Zod 간이 변환.
+     */
+    private jsonSchemaToZod;
+    /**
+     * Vercel AI SDK model 인스턴스 생성.
+     * provider string에 따라 적절한 SDK 팩토리 사용.
+     */
+    private createModel;
+}
+//# sourceMappingURL=mastra-runtime.d.ts.map

package/dist/provider/mastra-runtime.js

@@ -0,0 +1,208 @@
+"use strict";
+/**
+ * MastraProviderRuntime — API 프로바이더를 위한 ProviderRuntime 구현.
+ *
+ * Mastra Agent를 래핑하여 tool calling loop를 자동 처리한다.
+ * Vercel AI SDK 기반 모델 인스턴스를 생성하여 OpenRouter, OpenAI, Anthropic, Google 지원.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MastraProviderRuntime = void 0;
+const bridge_1 = require("./bridge");
+const DEFAULT_MAX_STEPS = 10;
+const MAX_STEPS_LIMIT = 50;
+class MastraProviderRuntime {
+    config;
+    constructor(config) {
+        this.config = config;
+    }
+    async query(message, options) {
+        return this._run(message, 'query', options);
+    }
+    async execute(message, options) {
+        return this._run(message, 'execute', options);
+    }
+    async _run(message, _mode, options) {
+        // 1. Mastra tools 변환
+        const mastraTools = this.convertTools(options?.tools ?? []);
+        // 2. Model 인스턴스 생성 (Vercel AI SDK)
+        const model = this.createModel(options?.model);
+        // 3. Mastra Agent 생성 (매 호출 fresh — stateless)
+        const { Agent } = await Promise.resolve().then(() => __importStar(require('@mastra/core/agent')));
+        const agent = new Agent({
+            name: this.config.provider,
+            model,
+            instructions: options?.systemPrompt ?? '',
+            tools: mastraTools,
+        });
+        // 4. generate() — tool loop 자동 실행
+        const maxSteps = Math.min(options?.maxSteps ?? this.config.maxSteps ?? DEFAULT_MAX_STEPS, MAX_STEPS_LIMIT);
+        try {
+            const result = await agent.generate(message, { maxSteps });
+            // 5. Usage 콜백
+            if (options?.onUsage && result.usage) {
+                const usage = {
+                    inputTokens: result.usage.promptTokens ?? 0,
+                    outputTokens: result.usage.completionTokens ?? 0,
+                    cachedInputTokens: 0,
+                    costUsd: 0,
+                };
+                options.onUsage(usage);
+            }
+            // 6. Model 콜백
+            if (options?.onModel) {
+                options.onModel(options.model ?? this.config.model);
+            }
+            // 7. 스트리밍 콜백 (Phase 1: generate 완료 후 전체 텍스트)
+            if (options?.onOutput && result.text) {
+                options.onOutput(result.text, 'stdout');
+            }
+            return result.text ?? '';
+        }
+        catch (error) {
+            if (error.status === 401) {
+                throw new bridge_1.ProviderError(`Authentication failed for ${this.config.provider}. Check your API key.`, this.config.provider);
+            }
+            if (error.status === 429) {
+                throw new bridge_1.ProviderError(`Rate limit exceeded for ${this.config.provider}.`, this.config.provider);
+            }
+            throw new bridge_1.ProviderError(`Provider error: ${error.message}`, this.config.provider);
+        }
+    }
+    /**
+     * CrewX ToolDefinition[] → Mastra tool Record 변환.
+     * JSON Schema → Zod 간이 변환 포함.
+     */
+    convertTools(tools) {
+        let createTool;
+        try {
+            createTool = require('@mastra/core/tools').createTool;
+        }
+        catch {
+            return {};
+        }
+        const { z } = require('zod');
+        const mastraTools = {};
+        for (const tool of tools) {
+            mastraTools[tool.name] = createTool({
+                id: tool.name,
+                description: tool.description,
+                inputSchema: this.jsonSchemaToZod(tool.parameters ?? {}, z),
+                execute: async ({ context }) => {
+                    return tool.execute(context);
+                },
+            });
+        }
+        return mastraTools;
+    }
+    /**
+     * JSON Schema → Zod 간이 변환.
+     */
+    jsonSchemaToZod(schema, z) {
+        if (!schema || !schema.properties)
+            return z.object({});
+        const shape = {};
+        const props = schema.properties;
+        const required = schema.required ?? [];
+        for (const [key, prop] of Object.entries(props)) {
+            let field;
+            switch (prop.type) {
+                case 'string':
+                    field = z.string();
+                    break;
+                case 'number':
+                    field = z.number();
+                    break;
+                case 'integer':
+                    field = z.number().int();
+                    break;
+                case 'boolean':
+                    field = z.boolean();
+                    break;
+                case 'array':
+                    field = z.array(z.any());
+                    break;
+                default: field = z.any();
+            }
+            if (prop.description)
+                field = field.describe(prop.description);
+            if (!required.includes(key))
+                field = field.optional();
+            shape[key] = field;
+        }
+        return z.object(shape);
+    }
+    /**
+     * Vercel AI SDK model 인스턴스 생성.
+     * provider string에 따라 적절한 SDK 팩토리 사용.
+     */
+    createModel(modelOverride) {
+        const { provider, apiKey, baseURL } = this.config;
+        const model = modelOverride || this.config.model;
+        switch (provider) {
+            case 'api/openrouter': {
+                const { createOpenAI } = require('@ai-sdk/openai');
+                return createOpenAI({
+                    apiKey: apiKey || process.env.OPENROUTER_API_KEY,
+                    baseURL: baseURL || 'https://openrouter.ai/api/v1',
+                })(model);
+            }
+            case 'api/openai': {
+                const { createOpenAI } = require('@ai-sdk/openai');
+                return createOpenAI({
+                    apiKey: apiKey || process.env.OPENAI_API_KEY,
+                    ...(baseURL && { baseURL }),
+                })(model);
+            }
+            case 'api/anthropic': {
+                const { createAnthropic } = require('@ai-sdk/anthropic');
+                return createAnthropic({
+                    apiKey: apiKey || process.env.ANTHROPIC_API_KEY,
+                    ...(baseURL && { baseURL }),
+                })(model);
+            }
+            case 'api/google': {
+                const { createGoogleGenerativeAI } = require('@ai-sdk/google');
+                return createGoogleGenerativeAI({
+                    apiKey: apiKey || process.env.GOOGLE_API_KEY,
+                })(model);
+            }
+            default:
+                throw new bridge_1.ProviderError(`Unsupported API provider: ${provider}`, provider);
+        }
+    }
+}
+exports.MastraProviderRuntime = MastraProviderRuntime;
+//# sourceMappingURL=mastra-runtime.js.map

package/dist/provider/parse-usage.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Pure function to extract token usage from provider CLI stdout.
+ * Supports Claude / Codex / Gemini / Copilot / OpenCode JSONL formats.
+ * Uses last-match semantics: if multiple usage events are found, the last one wins.
+ */
+export interface ParsedUsage {
+    inputTokens: number;
+    outputTokens: number;
+    /** Cached tokens (read from cache). */
+    cachedInputTokens: number;
+}
+/**
+ * Parse token usage from a provider CLI stdout string.
+ *
+ * Accepts JSONL (one JSON object per line) or a single JSON document.
+ * Returns the **last** usage found (last-match semantics).
+ * Returns `undefined` if no usage data is present.
+ */
+export declare function parseUsage(stdout: string): ParsedUsage | undefined;
+//# sourceMappingURL=parse-usage.d.ts.map