@crewx/sdk 0.8.0-rc.72 → 0.8.0-rc.74

package/dist/esm/provider/bridge.js

@@ -0,0 +1,373 @@
+/**
+ * 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().
+ */
+import { spawn } from 'child_process';
+export class ProviderError extends Error {
+    providerStr;
+    constructor(message, providerStr) {
+        super(message);
+        this.providerStr = providerStr;
+        this.name = '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().
+ */
+export class ClientToolCallRequiredError extends Error {
+    toolCall;
+    continuationState;
+    name = 'ClientToolCallRequiredError';
+    constructor(toolCall, continuationState) {
+        super(`Client tool call required: ${toolCall.toolName}`);
+        this.toolCall = toolCall;
+        this.continuationState = continuationState;
+    }
+}
+// ── 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');
+ */
+export 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
+ */
+export 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 = spawn(this.cliCommand, args, {
+                env: { ...process.env, ...(options?.env ?? {}) },
+                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)
+                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 };
+    }
+    /**
+     * Parse JSONL stream output and extract assistant text.
+     * Falls back to raw stdout if parsing fails.
+     */
+    parseOutput(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', text: '...' } }
+                if (parsed.type === 'item.completed' &&
+                    parsed.item?.type === '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;
+        // Plain text fallback
+        return raw.trim();
+    }
+    /**
+     * 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 lines = raw.split('\n');
+        let opencodeUsage = null;
+        for (const line of lines) {
+            if (!line.trim())
+                continue;
+            try {
+                const parsed = JSON.parse(line);
+                // OpenCode step_finish — use last-match semantics (same as parseUsage)
+                if (parsed.type === 'step_finish') {
+                    const part = parsed.part;
+                    const tokens = part?.['tokens'];
+                    if (tokens) {
+                        const inputRaw = Number(tokens['input'] ?? 0);
+                        const outputTokens = Number(tokens['output'] ?? 0);
+                        const cache = tokens['cache'];
+                        const cacheRead = cache ? Number(cache['read'] ?? 0) : 0;
+                        opencodeUsage = {
+                            inputTokens: inputRaw + cacheRead,
+                            outputTokens,
+                            cachedInputTokens: cacheRead,
+                            costUsd: 0, // cost collection is Phase 2 scope
+                        };
+                    }
+                }
+                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),
+                        }
+                        : null;
+                    // Extract model from modelUsage keys (e.g. { "claude-opus-4-6": {...} })
+                    const modelUsage = parsed.modelUsage;
+                    const model = modelUsage ? Object.keys(modelUsage)[0] ?? null : null;
+                    return { usage, model };
+                }
+            }
+            catch {
+                // Not JSON — skip
+            }
+        }
+        // Return OpenCode usage if found (no `result` event in OpenCode stream)
+        return { usage: opencodeUsage, model: null };
+    }
+}
+//# sourceMappingURL=bridge.js.map

package/dist/esm/provider/parse-usage.js

@@ -0,0 +1,80 @@
+/**
+ * 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.
+ */
+function extractFromFlat(obj) {
+    // Pattern: { type: "usage", input_tokens, output_tokens, [cache_read_input_tokens], [cached_input_tokens] }
+    if (obj['type'] !== 'usage' || !('input_tokens' in obj))
+        return null;
+    const inputRaw = Number(obj['input_tokens'] ?? 0);
+    const outputTokens = Number(obj['output_tokens'] ?? 0);
+    // cache_read_input_tokens takes precedence over cached_input_tokens
+    const hasCacheRead = 'cache_read_input_tokens' in obj;
+    const cacheRead = hasCacheRead ? Number(obj['cache_read_input_tokens']) : undefined;
+    const cachedInput = 'cached_input_tokens' in obj ? Number(obj['cached_input_tokens']) : undefined;
+    const cachedInputTokens = cacheRead !== undefined ? cacheRead : (cachedInput ?? 0);
+    // For cache_read_input_tokens: normalize — input_tokens represents fresh-only, total = input + cache_read
+    const inputTokens = cacheRead !== undefined ? inputRaw + cacheRead : inputRaw;
+    return { inputTokens, outputTokens, cachedInputTokens };
+}
+function extractFromNested(obj) {
+    // Pattern: { usage: { input_tokens, output_tokens, [cache_read_input_tokens], [cached_input_tokens] } }
+    const usageRaw = obj['usage'];
+    if (!usageRaw || typeof usageRaw !== 'object' || Array.isArray(usageRaw))
+        return null;
+    const usage = usageRaw;
+    if (!('input_tokens' in usage))
+        return null;
+    const inputRaw = Number(usage['input_tokens'] ?? 0);
+    const outputTokens = Number(usage['output_tokens'] ?? 0);
+    const hasCacheRead = 'cache_read_input_tokens' in usage;
+    const cacheRead = hasCacheRead ? Number(usage['cache_read_input_tokens']) : undefined;
+    const cachedInput = 'cached_input_tokens' in usage ? Number(usage['cached_input_tokens']) : undefined;
+    const cachedInputTokens = cacheRead !== undefined ? cacheRead : (cachedInput ?? 0);
+    const inputTokens = cacheRead !== undefined ? inputRaw + cacheRead : inputRaw;
+    return { inputTokens, outputTokens, cachedInputTokens };
+}
+function extractFromOpencode(obj) {
+    // Pattern: { type: "step_finish", part: { tokens: { input, output, cache: { read, write } } } }
+    if (obj['type'] !== 'step_finish')
+        return null;
+    const part = obj['part'];
+    const tokens = part?.['tokens'];
+    if (!tokens)
+        return null;
+    const inputRaw = Number(tokens['input'] ?? 0);
+    const outputTokens = Number(tokens['output'] ?? 0);
+    const cache = tokens['cache'];
+    const cacheRead = cache ? Number(cache['read'] ?? 0) : 0;
+    // normalize: cached tokens are included in input total (same as claude cache_read handling)
+    const inputTokens = inputRaw + cacheRead;
+    return { inputTokens, outputTokens, cachedInputTokens: cacheRead };
+}
+/**
+ * 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 function parseUsage(stdout) {
+    if (!stdout || !stdout.trim())
+        return undefined;
+    let last = null;
+    for (const line of stdout.split('\n')) {
+        if (!line.trim())
+            continue;
+        try {
+            const obj = JSON.parse(line);
+            const result = extractFromFlat(obj) ?? extractFromNested(obj) ?? extractFromOpencode(obj);
+            if (result)
+                last = result;
+        }
+        catch {
+            // non-JSON line — skip
+        }
+    }
+    return last ?? undefined;
+}
+//# sourceMappingURL=parse-usage.js.map

package/dist/esm/provider/register-api.js

@@ -0,0 +1,21 @@
+/**
+ * api/* namespace를 provider registry에 등록.
+ *
+ * crewx.yaml에서 provider: api/openrouter 등을 쓰면
+ * createProvider('api/openrouter') → VercelProviderRuntime 반환.
+ */
+import { registerProviderFactory } from './bridge';
+import { VercelProviderRuntime } from './vercel-runtime';
+export function registerApiProviders(globalConfig) {
+    registerProviderFactory('api', (id, providerStr) => {
+        const apiKey = globalConfig?.apiKeys?.[id];
+        return new VercelProviderRuntime({
+            provider: providerStr,
+            model: '', // query() 호출 시 options.model로 override
+            apiKey,
+            maxSteps: globalConfig?.defaults?.maxSteps,
+            temperature: globalConfig?.defaults?.temperature,
+        });
+    });
+}
+//# sourceMappingURL=register-api.js.map