@kinqs/brainrouter-cli 0.3.6 → 0.3.8

package/dist/prompt/skillCatalog.js

@@ -0,0 +1,134 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { createRequire } from 'node:module';
+const requireFromHere = createRequire(import.meta.url);
+const WORKSPACE_SKILL_ROOTS = ['skills', '.brainrouter/skills'];
+export function listFilesystemSkills(workspaceRoot) {
+    const seen = new Map();
+    for (const root of skillSearchRoots(workspaceRoot)) {
+        if (!fs.existsSync(root))
+            continue;
+        const scope = inferRootScope(root, workspaceRoot);
+        for (const filePath of findSkillFiles(root)) {
+            const parsed = parseSkillFile(filePath);
+            if (!parsed)
+                continue;
+            const rel = path.relative(root, filePath);
+            const category = rel.split(path.sep)[0] || 'uncategorized';
+            if (!seen.has(parsed.name)) {
+                seen.set(parsed.name, {
+                    name: parsed.name,
+                    category,
+                    description: parsed.description,
+                    scope,
+                    source: 'filesystem',
+                });
+            }
+        }
+    }
+    return Array.from(seen.values()).sort(sortSkills);
+}
+export function mergeSkillLists(primary, fallback) {
+    const merged = new Map();
+    for (const skill of primary) {
+        merged.set(skill.name, { ...skill, source: skill.source ?? 'mcp' });
+    }
+    for (const skill of fallback) {
+        if (!merged.has(skill.name))
+            merged.set(skill.name, skill);
+    }
+    return Array.from(merged.values()).sort(sortSkills);
+}
+export function sortSkills(a, b) {
+    return (a.category ?? '').localeCompare(b.category ?? '') || a.name.localeCompare(b.name);
+}
+export function skillSearchRoots(workspaceRoot) {
+    const roots = [];
+    for (const sub of WORKSPACE_SKILL_ROOTS)
+        roots.push(path.join(workspaceRoot, sub));
+    const mcpPkgDir = resolveInstalledMcpPackageDir();
+    if (mcpPkgDir) {
+        roots.push(path.join(mcpPkgDir, 'skills'));
+        const monorepoRoot = path.dirname(mcpPkgDir);
+        roots.push(path.join(monorepoRoot, 'skills'));
+    }
+    return [...new Set(roots.map((root) => path.resolve(root)))];
+}
+function resolveInstalledMcpPackageDir() {
+    try {
+        const pkgJsonPath = requireFromHere.resolve('@kinqs/brainrouter-mcp-server/package.json');
+        return path.dirname(pkgJsonPath);
+    }
+    catch {
+        return undefined;
+    }
+}
+function inferRootScope(root, workspaceRoot) {
+    const resolvedWorkspace = path.resolve(workspaceRoot);
+    const resolvedRoot = path.resolve(root);
+    if (resolvedRoot.startsWith(path.join(resolvedWorkspace, '.brainrouter')))
+        return 'local';
+    if (isBrainRouterRepoRoot(path.dirname(resolvedRoot)))
+        return 'global';
+    return resolvedRoot.startsWith(resolvedWorkspace) ? 'local' : 'global';
+}
+function isBrainRouterRepoRoot(root) {
+    return (fs.existsSync(path.join(root, 'brainrouter', 'package.json')) &&
+        fs.existsSync(path.join(root, 'brainrouter-cli', 'package.json')) &&
+        fs.existsSync(path.join(root, 'skills')));
+}
+function findSkillFiles(root) {
+    const results = [];
+    function walk(current, depth) {
+        if (depth < 0)
+            return;
+        let entries;
+        try {
+            entries = fs.readdirSync(current, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            if (entry.name === 'node_modules' || entry.name === '.git')
+                continue;
+            const full = path.join(current, entry.name);
+            if (entry.isDirectory())
+                walk(full, depth - 1);
+            else if (entry.isFile() && entry.name === 'SKILL.md')
+                results.push(full);
+        }
+    }
+    walk(root, 5);
+    return results;
+}
+function parseSkillFile(filePath) {
+    let raw;
+    try {
+        raw = fs.readFileSync(filePath, 'utf8');
+    }
+    catch {
+        return undefined;
+    }
+    const frontmatter = raw.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+    const block = frontmatter?.[1] ?? '';
+    const name = readYamlScalar(block, 'name') ?? path.basename(path.dirname(filePath));
+    const description = readYamlScalar(block, 'description') ?? firstParagraph(raw);
+    if (!name)
+        return undefined;
+    return { name, description };
+}
+function readYamlScalar(block, key) {
+    const match = block.match(new RegExp(`^${key}:\\s*(.+)$`, 'm'));
+    if (!match?.[1])
+        return undefined;
+    return match[1].trim().replace(/^['"]|['"]$/g, '');
+}
+function firstParagraph(raw) {
+    const withoutFrontmatter = raw.replace(/^---\r?\n[\s\S]*?\r?\n---/, '').trim();
+    const line = withoutFrontmatter
+        .split(/\r?\n/)
+        .map((part) => part.trim())
+        .find((part) => part && !part.startsWith('#'));
+    return line;
+}

package/dist/prompt/skillRunner.d.ts

@@ -1,4 +1,4 @@
-import type { McpClientWrapper } from '../runtime/mcpClient.js';
+import type { McpClient } from '../runtime/mcpUtils.js';
 export interface SkillResolution {
     name: string;
     body: string;
@@ -24,7 +24,7 @@ export declare const SLASH_TO_SKILL: Record<string, string>;
  * server has loaded, including their own private skills), falls back to a
  * local filesystem scan of `skills/` for when the MCP tool is unavailable.
  */
-export declare function resolveSkill(mcpClient: McpClientWrapper, name: string, workspaceRoot: string, section?: RunSkillOptions['section']): Promise<SkillResolution>;
+export declare function resolveSkill(mcpClient: McpClient, name: string, workspaceRoot: string, section?: RunSkillOptions['section']): Promise<SkillResolution>;
 /**
  * Build the user prompt that asks the agent to execute a skill. The skill
  * body is embedded so the agent does not need to round-trip through

package/dist/prompt/skillRunner.js

@@ -1,7 +1,6 @@
 import fs from 'node:fs';
 import path from 'node:path';
-import { createRequire } from 'node:module';
-const requireFromHere = createRequire(import.meta.url);
+import { skillSearchRoots } from './skillCatalog.js';
 /**
  * Slash-command → skill mapping. Each entry names the skill catalogued in
  * the BrainRouter skills/ folder (and exposed by the MCP server) that the
@@ -21,7 +20,6 @@ export const SLASH_TO_SKILL = {
     '/refactor': 'code-simplification',
     '/test': 'testing-skill',
 };
-const WORKSPACE_SKILL_ROOTS = ['skills', '.brainrouter/skills'];
 /**
  * Resolve a skill by name. Prefers the MCP server (so users get whatever the
  * server has loaded, including their own private skills), falls back to a
@@ -61,34 +59,7 @@ function readSkillFromFilesystem(workspaceRoot, name) {
     }
     return undefined;
 }
-/**
- * Roots to search for SKILL.md when the MCP server is unavailable. Includes:
- *  - the user's workspace (so per-project skills win locally)
- *  - the installed @kinqs/brainrouter-mcp-server package directory (so the canonical
- *    BrainRouter catalogue is found even when MCP is down, because prepack
- *    bundles `skills/` into the published package)
- *  - the monorepo root (when running from source during development)
- */
-function skillSearchRoots(workspaceRoot) {
-    const roots = [];
-    for (const sub of WORKSPACE_SKILL_ROOTS) {
-        roots.push(path.join(workspaceRoot, sub));
-    }
-    const mcpPkgDir = resolveInstalledMcpPackageDir();
-    if (mcpPkgDir)
-        roots.push(path.join(mcpPkgDir, 'skills'));
-    return roots;
-}
-function resolveInstalledMcpPackageDir() {
-    try {
-        const pkgJsonPath = requireFromHere.resolve('@kinqs/brainrouter-mcp-server/package.json');
-        return path.dirname(pkgJsonPath);
-    }
-    catch {
-        return undefined;
-    }
-}
-function findSkillDir(rootDir, skillName, depth = 3) {
+function findSkillDir(rootDir, skillName, depth = 5) {
     if (depth < 0)
         return undefined;
     let entries;

package/dist/prompt/systemPrompt.js

@@ -77,7 +77,11 @@ function clarifyOverlay(activeSkill) {
 function isBrainOnline(connectedTools) {
     if (!connectedTools)
         return true;
-    return connectedTools.includes('memory_recall');
+    // Match bare `memory_recall` and the canonical single-underscore prefixed
+    // form `mcp_<server>_memory_recall` (pool normalises any legacy
+    // double-underscore emissions at the boundary — 0.3.8-R5).
+    return connectedTools.some((tool) => tool === 'memory_recall' ||
+        (tool.startsWith('mcp_') && tool.endsWith('memory_recall')));
 }
 function brainOfflineNotice() {
     return [
@@ -123,7 +127,8 @@ export function buildSystemPrompt(context) {
         brainOnline ? memoryFirstSection() : brainOfflineNotice(),
         '',
         '## Multi-agent orchestration',
-        '- Delegate parallel, bounded work via `spawn_agent` (one) or `spawn_agents` (batch). Roles: explorer (read-only investigation), architect (design alternatives), reviewer (code review), worker (write access), verifier (tests/checks). Omit `role` in `spawn_agents` to auto-route from the leading verb; use `route_agent` for a dry run.',
+        '- Delegation order: direct answer → direct tool → `task_agent` for needed child results → `delegate_agent` when you can keep working. `spawn_agent` / `spawn_agents` are low-level compatibility/batch tools.',
+        '- Roles: explorer, architect, reviewer, worker, verifier. Omit `role` in `spawn_agents` to auto-route from the leading verb; use `route_agent` for a dry run.',
         '- Fan-out triggers: phrasings like "everything", "all", "in 1 go", "in parallel", "thoroughly", "comprehensive", "across the codebase" → ALWAYS `spawn_agents` with ≥3 children. One tool call + "what next?" is NOT acceptable for those prompts.',
         '- Use `wait_agent` / `wait_agents` to drain before yielding. Synthesize child outputs in your own words — never claim work is done just because a child returned.',
         '',

package/dist/runtime/anthropicAdapter.d.ts

@@ -0,0 +1,100 @@
+import type { LLMConfig } from '../config/config.js';
+import type { EffortLevel } from '../state/preferencesStore.js';
+/**
+ * Route to the native adapter when the profile is Anthropic AND the
+ * endpoint hostname is `api.anthropic.com`, OR the explicit
+ * `BRAINROUTER_ANTHROPIC_NATIVE=1` override is set (for vended /
+ * reverse-proxied endpoints that still speak the native shape).
+ *
+ * Anything else — including `provider:'anthropic'` pointed at an
+ * OpenAI-compat gateway — stays on the existing OpenAI path so we
+ * don't break the OpenRouter / Anthropic-compat-shim flows.
+ */
+export declare function shouldUseAnthropicNative(config: LLMConfig, env?: NodeJS.ProcessEnv): boolean;
+export interface AnthropicBuildOptions {
+    effort?: EffortLevel;
+    cacheEnabled?: boolean;
+    maxTokens?: number;
+    thinkingBudgetTokens?: number;
+}
+interface AnthropicMessage {
+    role: 'user' | 'assistant';
+    content: any[];
+}
+interface AnthropicTool {
+    name: string;
+    description: string;
+    input_schema: any;
+    cache_control?: {
+        type: 'ephemeral';
+    };
+}
+export interface AnthropicRequestPayload {
+    model: string;
+    max_tokens: number;
+    system?: any;
+    messages: AnthropicMessage[];
+    tools?: AnthropicTool[];
+    thinking?: {
+        type: 'enabled';
+        budget_tokens: number;
+    };
+}
+/**
+ * Pure transform: BrainRouter chat history (OpenAI shape) →
+ * Anthropic `/v1/messages` request body.
+ *
+ * Invariants enforced here so callers don't need to know the Anthropic
+ * rules:
+ *   - The system message (first message with role:'system') is hoisted
+ *     to the top-level `system` field and dropped from `messages`.
+ *   - Consecutive `tool` role entries are merged into one synthetic
+ *     `user` message whose content is an array of `tool_result` blocks.
+ *   - Assistant messages with `tool_calls` emit a content array that
+ *     interleaves text (when present) and `tool_use` blocks. The
+ *     OpenAI tool_call.id is reused as the Anthropic tool_use.id —
+ *     callers must echo it back on the matching tool_result.
+ */
+export declare function buildAnthropicRequest(config: LLMConfig, messages: any[], tools: any[], options?: AnthropicBuildOptions): AnthropicRequestPayload;
+export interface AnthropicParsedResponse {
+    content: string;
+    toolCalls?: Array<{
+        id: string;
+        type: 'function';
+        function: {
+            name: string;
+            arguments: string;
+        };
+    }>;
+    usage?: {
+        prompt_tokens?: number;
+        completion_tokens?: number;
+    };
+    thinking?: string;
+}
+/**
+ * Pure transform: Anthropic response body → BrainRouter's internal
+ * `ChatResponse` shape. tool_use blocks become OpenAI-style toolCalls
+ * with the Anthropic id preserved verbatim, and `input` is re-serialized
+ * to the `function.arguments` JSON string the agent loop expects.
+ */
+export declare function parseAnthropicResponse(data: any): AnthropicParsedResponse;
+export interface CallAnthropicOptions extends AnthropicBuildOptions {
+    onThinking?: (text: string) => void;
+}
+export declare function callAnthropic(config: LLMConfig, messages: any[], tools: any[], options?: CallAnthropicOptions): Promise<{
+    content: string;
+    toolCalls: {
+        id: string;
+        type: "function";
+        function: {
+            name: string;
+            arguments: string;
+        };
+    }[] | undefined;
+    usage: {
+        prompt_tokens?: number;
+        completion_tokens?: number;
+    } | undefined;
+}>;
+export {};

package/dist/runtime/anthropicAdapter.js

@@ -0,0 +1,293 @@
+// 0.3.8-I6: Native Anthropic `/v1/messages` adapter.
+//
+// BrainRouter's agent loop keeps chat history in OpenAI's shape
+// (`{role:'system'|'user'|'assistant'|'tool', content, tool_calls?,
+// tool_call_id?, name?}`) because that's the schema every other vendor
+// in the catalog already speaks. This module is the ONE place that hides
+// Anthropic's asymmetric shape from the rest of the codebase:
+//
+//   - `system` is a top-level field, not a `messages[]` entry.
+//   - Tool results come back as `tool_result` blocks WRAPPED in a `user`
+//     message — there is no `tool` role.
+//   - Multiple pending tool_results must collapse into one user turn
+//     with a content array, not one user message per result.
+//   - `tool_use` ids are vendor-assigned and must round-trip verbatim.
+//   - `max_tokens` is REQUIRED (OpenAI treats it as optional).
+//   - Prompt caching breakpoints and extended thinking are first-class
+//     request fields, not headers.
+//
+// Streaming is out of scope for this PR — the agent loop still polls
+// non-streaming responses.
+import { acquireLLMSlot } from './llmSemaphore.js';
+const ANTHROPIC_API_VERSION = '2023-06-01';
+/**
+ * Route to the native adapter when the profile is Anthropic AND the
+ * endpoint hostname is `api.anthropic.com`, OR the explicit
+ * `BRAINROUTER_ANTHROPIC_NATIVE=1` override is set (for vended /
+ * reverse-proxied endpoints that still speak the native shape).
+ *
+ * Anything else — including `provider:'anthropic'` pointed at an
+ * OpenAI-compat gateway — stays on the existing OpenAI path so we
+ * don't break the OpenRouter / Anthropic-compat-shim flows.
+ */
+export function shouldUseAnthropicNative(config, env = process.env) {
+    if (config.provider !== 'anthropic')
+        return false;
+    if (env.BRAINROUTER_ANTHROPIC_NATIVE === '1')
+        return true;
+    const endpoint = config.endpoint ?? 'https://api.anthropic.com/v1';
+    try {
+        const host = new URL(endpoint).hostname.toLowerCase();
+        return host === 'api.anthropic.com' || host.endsWith('.anthropic.com');
+    }
+    catch {
+        return false;
+    }
+}
+function modelDefaultMaxTokens(model) {
+    const m = model.toLowerCase();
+    if (m.includes('haiku'))
+        return 2048;
+    return 4096;
+}
+function supportsExtendedThinking(model) {
+    // Sonnet 4.x / Opus 4.x families. Strip any vendor prefix.
+    const m = model.toLowerCase().split('/').pop() ?? '';
+    return /claude-(?:[a-z0-9.-]*-)?(sonnet|opus)-4/.test(m);
+}
+/**
+ * Pure transform: BrainRouter chat history (OpenAI shape) →
+ * Anthropic `/v1/messages` request body.
+ *
+ * Invariants enforced here so callers don't need to know the Anthropic
+ * rules:
+ *   - The system message (first message with role:'system') is hoisted
+ *     to the top-level `system` field and dropped from `messages`.
+ *   - Consecutive `tool` role entries are merged into one synthetic
+ *     `user` message whose content is an array of `tool_result` blocks.
+ *   - Assistant messages with `tool_calls` emit a content array that
+ *     interleaves text (when present) and `tool_use` blocks. The
+ *     OpenAI tool_call.id is reused as the Anthropic tool_use.id —
+ *     callers must echo it back on the matching tool_result.
+ */
+export function buildAnthropicRequest(config, messages, tools, options = {}) {
+    let systemText;
+    const out = [];
+    let pendingToolResults = null;
+    const flushToolResults = () => {
+        if (pendingToolResults && pendingToolResults.length > 0) {
+            out.push({ role: 'user', content: pendingToolResults });
+        }
+        pendingToolResults = null;
+    };
+    for (const m of messages) {
+        if (m.role === 'system') {
+            // First system message wins; later ones are concatenated so
+            // tagged system prompts (replaceTaggedSystemMessage) still flow.
+            const text = typeof m.content === 'string' ? m.content : JSON.stringify(m.content);
+            systemText = systemText ? `${systemText}\n\n${text}` : text;
+            continue;
+        }
+        if (m.role === 'tool') {
+            const block = {
+                type: 'tool_result',
+                tool_use_id: m.tool_call_id,
+                content: typeof m.content === 'string' ? m.content : JSON.stringify(m.content),
+            };
+            if (!pendingToolResults)
+                pendingToolResults = [];
+            pendingToolResults.push(block);
+            continue;
+        }
+        flushToolResults();
+        if (m.role === 'assistant') {
+            const blocks = [];
+            const text = typeof m.content === 'string' ? m.content : '';
+            if (text)
+                blocks.push({ type: 'text', text });
+            if (Array.isArray(m.tool_calls)) {
+                for (const tc of m.tool_calls) {
+                    let input = {};
+                    const raw = tc?.function?.arguments;
+                    if (typeof raw === 'string' && raw.trim()) {
+                        try {
+                            input = JSON.parse(raw);
+                        }
+                        catch {
+                            input = { _raw: raw };
+                        }
+                    }
+                    else if (raw && typeof raw === 'object') {
+                        input = raw;
+                    }
+                    blocks.push({
+                        type: 'tool_use',
+                        id: tc.id,
+                        name: tc.function?.name,
+                        input,
+                    });
+                }
+            }
+            // An assistant turn with NO content + no tool_calls is dropped —
+            // Anthropic rejects empty assistant turns.
+            if (blocks.length > 0)
+                out.push({ role: 'assistant', content: blocks });
+            continue;
+        }
+        // user
+        const userText = typeof m.content === 'string' ? m.content : JSON.stringify(m.content);
+        out.push({ role: 'user', content: [{ type: 'text', text: userText }] });
+    }
+    flushToolResults();
+    const body = {
+        model: config.model,
+        max_tokens: options.maxTokens ?? modelDefaultMaxTokens(config.model),
+        messages: out,
+    };
+    if (systemText) {
+        if (options.cacheEnabled) {
+            body.system = [{ type: 'text', text: systemText, cache_control: { type: 'ephemeral' } }];
+        }
+        else {
+            body.system = systemText;
+        }
+    }
+    if (tools.length > 0) {
+        body.tools = tools.map((t) => ({
+            name: t.name,
+            description: t.description || '',
+            input_schema: t.inputSchema || { type: 'object', properties: {} },
+        }));
+    }
+    // Cache breakpoint on the last assistant message (its last block) so
+    // every subsequent turn reads the prior context from cache.
+    if (options.cacheEnabled) {
+        for (let i = body.messages.length - 1; i >= 0; i--) {
+            const msg = body.messages[i];
+            if (msg.role === 'assistant' && Array.isArray(msg.content) && msg.content.length > 0) {
+                const last = msg.content[msg.content.length - 1];
+                last.cache_control = { type: 'ephemeral' };
+                break;
+            }
+        }
+    }
+    if (options.effort === 'high' &&
+        supportsExtendedThinking(config.model)) {
+        body.thinking = {
+            type: 'enabled',
+            budget_tokens: options.thinkingBudgetTokens ?? 8000,
+        };
+    }
+    return body;
+}
+/**
+ * Pure transform: Anthropic response body → BrainRouter's internal
+ * `ChatResponse` shape. tool_use blocks become OpenAI-style toolCalls
+ * with the Anthropic id preserved verbatim, and `input` is re-serialized
+ * to the `function.arguments` JSON string the agent loop expects.
+ */
+export function parseAnthropicResponse(data) {
+    if (!data || typeof data !== 'object') {
+        throw new Error(`Anthropic response was not a JSON object: ${JSON.stringify(data).slice(0, 400)}`);
+    }
+    if (data.type === 'error' || data.error) {
+        const err = data.error ?? data;
+        const msg = typeof err === 'string' ? err : (err.message ?? JSON.stringify(err));
+        throw new Error(`Anthropic API error: ${msg}`);
+    }
+    const blocks = Array.isArray(data.content) ? data.content : [];
+    const textParts = [];
+    const thinkingParts = [];
+    const toolCalls = [];
+    for (const b of blocks) {
+        if (!b || typeof b !== 'object')
+            continue;
+        if (b.type === 'text' && typeof b.text === 'string') {
+            textParts.push(b.text);
+        }
+        else if (b.type === 'thinking' && typeof b.thinking === 'string') {
+            thinkingParts.push(b.thinking);
+        }
+        else if (b.type === 'tool_use') {
+            toolCalls.push({
+                id: b.id,
+                type: 'function',
+                function: {
+                    name: b.name,
+                    arguments: JSON.stringify(b.input ?? {}),
+                },
+            });
+        }
+    }
+    const usage = data.usage
+        ? {
+            prompt_tokens: data.usage.input_tokens,
+            completion_tokens: data.usage.output_tokens,
+        }
+        : undefined;
+    const result = {
+        content: textParts.join(''),
+        usage,
+    };
+    if (toolCalls.length > 0)
+        result.toolCalls = toolCalls;
+    if (thinkingParts.length > 0)
+        result.thinking = thinkingParts.join('');
+    return result;
+}
+export async function callAnthropic(config, messages, tools, options = {}) {
+    const rawEndpoint = config.endpoint || 'https://api.anthropic.com/v1';
+    const endpoint = rawEndpoint.replace(/\/+$/, '').replace(/\/messages$/, '');
+    const apiKey = config.apiKey || process.env.ANTHROPIC_API_KEY || '';
+    if (!apiKey) {
+        throw new Error('Anthropic API key is required (set ANTHROPIC_API_KEY or config.llm.apiKey).');
+    }
+    const cacheEnabled = process.env.BRAINROUTER_ANTHROPIC_CACHE === '1';
+    const body = buildAnthropicRequest(config, messages, tools, {
+        ...options,
+        cacheEnabled: options.cacheEnabled ?? cacheEnabled,
+    });
+    const headers = {
+        'Content-Type': 'application/json',
+        'x-api-key': apiKey,
+        'anthropic-version': ANTHROPIC_API_VERSION,
+    };
+    const timeoutMs = Number(process.env.BRAINROUTER_LLM_TIMEOUT_MS || 120000);
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), timeoutMs);
+    const release = await acquireLLMSlot();
+    let res;
+    try {
+        res = await fetch(`${endpoint}/messages`, {
+            method: 'POST',
+            headers,
+            body: JSON.stringify(body),
+            signal: controller.signal,
+        });
+    }
+    catch (err) {
+        release();
+        if (err?.name === 'AbortError') {
+            throw new Error(`Anthropic request timed out after ${timeoutMs}ms.`);
+        }
+        throw err;
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+    release();
+    if (!res.ok) {
+        const errText = await res.text();
+        throw new Error(`Anthropic API error: ${res.status} ${res.statusText} - ${errText}`);
+    }
+    const data = await res.json();
+    const parsed = parseAnthropicResponse(data);
+    if (parsed.thinking && options.onThinking) {
+        options.onThinking(parsed.thinking);
+    }
+    return {
+        content: parsed.content,
+        toolCalls: parsed.toolCalls,
+        usage: parsed.usage,
+    };
+}

package/dist/runtime/cronParser.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Minimal 5-field cron parser — `minute hour dom month dow`.
+ *
+ * Vendored intentionally (no node-cron) to keep the dependency surface
+ * small and the semantics predictable. Supports `*`, comma lists,
+ * ranges (`1-5`), and steps (`15`, `0-30/10`). No seconds, no Quartz
+ * extensions, no `@reboot` macros.
+ */
+export interface CronExpr {
+    minute: Set<number>;
+    hour: Set<number>;
+    dom: Set<number>;
+    month: Set<number>;
+    dow: Set<number>;
+    raw: string;
+}
+export declare function parseCron(expr: string): CronExpr | undefined;
+/**
+ * First firing instant strictly AFTER `after`. Walks the calendar
+ * forward, jumping months/days when fields don't match instead of
+ * scanning minute-by-minute.
+ */
+export declare function nextCronFire(cron: CronExpr, after: Date): Date;