@synergenius/flowweaver-pack-weaver 0.6.1 → 0.7.1

package/dist/workflows/weaver-bot-batch.d.ts

@@ -38,7 +38,10 @@
  * @returns onFailure [order:-1] [hidden] - On Failure
  * @returns summary [order:0] - Summary text
  */
-export declare function weaverBotBatch(execute: boolean, taskJson?: string, projectDir?: string, __abortSignal__?: AbortSignal): Promise<{
+export declare function weaverBotBatch(execute: boolean, params: {
+    taskJson?: string;
+    projectDir?: string;
+}, __abortSignal__?: AbortSignal): Promise<{
     onSuccess: boolean;
     onFailure: boolean;
     summary: string | null;

package/dist/workflows/weaver-bot-batch.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"weaver-bot-batch.d.ts","sourceRoot":"","sources":["../../src/workflows/weaver-bot-batch.ts"],"names":[],"mappings":"AAeA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH,wBAAsB,cAAc,CAClC,OAAO,EAAE,OAAO,EAChB,QAAQ,CAAC,EAAE,MAAM,EACjB,UAAU,CAAC,EAAE,MAAM,EACnB,eAAe,CAAC,EAAE,WAAW,GAC5B,OAAO,CAAC;IAAE,SAAS,EAAE,OAAO,CAAC;IAAC,SAAS,EAAE,OAAO,CAAC;IAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE,CAAC,CAK7E"}
+{"version":3,"file":"weaver-bot-batch.d.ts","sourceRoot":"","sources":["../../src/workflows/weaver-bot-batch.ts"],"names":[],"mappings":"AAeA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH,wBAAsB,cAAc,CAClC,OAAO,EAAE,OAAO,EAChB,MAAM,EAAE;IAAE,QAAQ,CAAC,EAAE,MAAM,CAAC;IAAC,UAAU,CAAC,EAAE,MAAM,CAAA;CAAE,EAClD,eAAe,CAAC,EAAE,WAAW,GAC5B,OAAO,CAAC;IAAE,SAAS,EAAE,OAAO,CAAC;IAAC,SAAS,EAAE,OAAO,CAAC;IAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE,CAAC,CAK7E"}

package/dist/workflows/weaver-bot-batch.js

@@ -40,7 +40,7 @@
  * @returns onFailure [order:-1] [hidden] - On Failure
  * @returns summary [order:0] - Summary text
  */
-export async function weaverBotBatch(execute, taskJson, projectDir, __abortSignal__) {
+export async function weaverBotBatch(execute, params, __abortSignal__) {
     // @flow-weaver-body-start
     // (auto-generated by compiler)
     // @flow-weaver-body-end

package/dist/workflows/weaver-bot-batch.js.map

@@ -1 +1 @@
-{"version":3,"file":"weaver-bot-batch.js","sourceRoot":"","sources":["../../src/workflows/weaver-bot-batch.ts"],"names":[],"mappings":"AAAA,kFAAkF;AAClF,mCAAmC;AAcnC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH,MAAM,CAAC,KAAK,UAAU,cAAc,CAClC,OAAgB,EAChB,QAAiB,EACjB,UAAmB,EACnB,eAA6B;IAE7B,0BAA0B;IAC1B,+BAA+B;IAC/B,wBAAwB;IACxB,OAAO,EAAE,SAAS,EAAE,KAAK,EAAE,SAAS,EAAE,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC;AAC9D,CAAC"}
+{"version":3,"file":"weaver-bot-batch.js","sourceRoot":"","sources":["../../src/workflows/weaver-bot-batch.ts"],"names":[],"mappings":"AAAA,kFAAkF;AAClF,mCAAmC;AAcnC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH,MAAM,CAAC,KAAK,UAAU,cAAc,CAClC,OAAgB,EAChB,MAAkD,EAClD,eAA6B;IAE7B,0BAA0B;IAC1B,+BAA+B;IAC/B,wBAAwB;IACxB,OAAO,EAAE,SAAS,EAAE,KAAK,EAAE,SAAS,EAAE,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC;AAC9D,CAAC"}

package/dist/workflows/weaver-bot.d.ts

@@ -50,7 +50,10 @@
  * @returns onFailure [order:-1] [hidden] - On Failure
  * @returns summary [order:0] - Summary text
  */
-export declare function weaverBot(execute: boolean, taskJson?: string, projectDir?: string, __abortSignal__?: AbortSignal): Promise<{
+export declare function weaverBot(execute: boolean, params: {
+    taskJson?: string;
+    projectDir?: string;
+}, __abortSignal__?: AbortSignal): Promise<{
     onSuccess: boolean;
     onFailure: boolean;
     summary: string | null;

package/dist/workflows/weaver-bot.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"weaver-bot.d.ts","sourceRoot":"","sources":["../../src/workflows/weaver-bot.ts"],"names":[],"mappings":"AAiBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmDG;AACH,wBAAsB,SAAS,CAC7B,OAAO,EAAE,OAAO,EAChB,QAAQ,CAAC,EAAE,MAAM,EACjB,UAAU,CAAC,EAAE,MAAM,EACnB,eAAe,CAAC,EAAE,WAAW,GAC5B,OAAO,CAAC;IAAE,SAAS,EAAE,OAAO,CAAC;IAAC,SAAS,EAAE,OAAO,CAAC;IAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE,CAAC,CAK7E"}
+{"version":3,"file":"weaver-bot.d.ts","sourceRoot":"","sources":["../../src/workflows/weaver-bot.ts"],"names":[],"mappings":"AAiBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmDG;AACH,wBAAsB,SAAS,CAC7B,OAAO,EAAE,OAAO,EAChB,MAAM,EAAE;IAAE,QAAQ,CAAC,EAAE,MAAM,CAAC;IAAC,UAAU,CAAC,EAAE,MAAM,CAAA;CAAE,EAClD,eAAe,CAAC,EAAE,WAAW,GAC5B,OAAO,CAAC;IAAE,SAAS,EAAE,OAAO,CAAC;IAAC,SAAS,EAAE,OAAO,CAAC;IAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE,CAAC,CAK7E"}

package/dist/workflows/weaver-bot.js

@@ -52,7 +52,7 @@
  * @returns onFailure [order:-1] [hidden] - On Failure
  * @returns summary [order:0] - Summary text
  */
-export async function weaverBot(execute, taskJson, projectDir, __abortSignal__) {
+export async function weaverBot(execute, params, __abortSignal__) {
     // @flow-weaver-body-start
     // (auto-generated by compiler)
     // @flow-weaver-body-end

package/dist/workflows/weaver-bot.js.map

@@ -1 +1 @@
-{"version":3,"file":"weaver-bot.js","sourceRoot":"","sources":["../../src/workflows/weaver-bot.ts"],"names":[],"mappings":"AAAA,yEAAyE;AACzE,mCAAmC;AAgBnC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmDG;AACH,MAAM,CAAC,KAAK,UAAU,SAAS,CAC7B,OAAgB,EAChB,QAAiB,EACjB,UAAmB,EACnB,eAA6B;IAE7B,0BAA0B;IAC1B,+BAA+B;IAC/B,wBAAwB;IACxB,OAAO,EAAE,SAAS,EAAE,KAAK,EAAE,SAAS,EAAE,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC;AAC9D,CAAC"}
+{"version":3,"file":"weaver-bot.js","sourceRoot":"","sources":["../../src/workflows/weaver-bot.ts"],"names":[],"mappings":"AAAA,yEAAyE;AACzE,mCAAmC;AAgBnC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmDG;AACH,MAAM,CAAC,KAAK,UAAU,SAAS,CAC7B,OAAgB,EAChB,MAAkD,EAClD,eAA6B;IAE7B,0BAA0B;IAC1B,+BAA+B;IAC/B,wBAAwB;IACxB,OAAO,EAAE,SAAS,EAAE,KAAK,EAAE,SAAS,EAAE,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC;AAC9D,CAAC"}

package/flowweaver.manifest.json

@@ -1,13 +1,35 @@
 {
   "manifestVersion": 1,
   "name": "@synergenius/flowweaver-pack-weaver",
-  "version": "0.6.1",
+  "version": "0.7.1",
   "description": "AI bot for Flow Weaver. Execute tasks, run workflows, evolve autonomously.",
   "engineVersion": ">=0.19.4",
   "categories": [
     "automation",
     "ai"
   ],
+  "botRegistrations": [
+    {
+      "id": "weaver-bot",
+      "name": "Weaver Bot",
+      "description": "AI-powered autonomous workflow creator",
+      "icon": "psychology",
+      "color": "#6366f1",
+      "workflowExport": "weaverBot",
+      "paramName": "taskJson",
+      "sourceTemplateId": "weaver-bot"
+    },
+    {
+      "id": "weaver-genesis",
+      "name": "Weaver Genesis",
+      "description": "Self-evolution cycle for a target workflow",
+      "icon": "autoAwesome",
+      "color": "#9f5fe3",
+      "workflowExport": "genesisTask",
+      "paramName": "config",
+      "sourceTemplateId": "genesis-task"
+    }
+  ],
   "nodeTypes": [
     {
       "name": "weaverLoadConfig",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@synergenius/flowweaver-pack-weaver",
-  "version": "0.6.1",
+  "version": "0.7.1",
   "description": "AI bot for Flow Weaver. Execute tasks, run workflows, evolve autonomously.",
   "type": "module",
   "main": "./dist/index.js",
@@ -36,7 +36,7 @@
   },
   "peerDependencies": {
     "@anthropic-ai/sdk": ">=0.30.0",
-    "@synergenius/flow-weaver": ">=0.20.5",
+    "@synergenius/flow-weaver": ">=0.21.0",
     "zod": ">=3.22.0"
   },
   "peerDependenciesMeta": {
@@ -49,6 +49,7 @@
   },
   "files": [
     "dist",
+    "src",
     "flowweaver.manifest.json",
     "templates.js",
     "LICENSE"

package/src/bot/agent-provider.ts

@@ -0,0 +1,273 @@
+import { execFileSync } from 'node:child_process';
+import type { BotProviderConfig, BotConfig, BotAgentProvider, OnUsageCallback, StreamChunk, ToolDefinition, ToolUseResult } from './types.js';
+import { buildSystemPrompt } from './system-prompt.js';
+import { defaultRegistry, loadExternalProvider } from './provider-registry.js';
+import type { ProviderRegistry } from './provider-registry.js';
+
+const WHICH_CMD = process.platform === 'win32' ? 'where' : 'which';
+
+export type { BotAgentProvider };
+
+export function resolveProviderConfig(
+  provider: BotConfig['provider'],
+): BotProviderConfig {
+  if (provider === 'auto') return detectProvider();
+  if (typeof provider === 'string') return { name: provider };
+  return provider;
+}
+
+export async function createProvider(
+  config: BotProviderConfig,
+  registry: ProviderRegistry = defaultRegistry,
+): Promise<BotAgentProvider> {
+  // If config.module is set, load and register it first
+  if (config.module) {
+    if (!registry.has(config.name)) {
+      const { factory, metadata } = await loadExternalProvider(config.module);
+      registry.register(config.name, factory, metadata);
+    }
+  }
+
+  // Check registry (covers built-ins + loaded externals)
+  const entry = registry.resolve(config.name);
+  if (entry) {
+    return entry.factory({
+      model: config.model,
+      maxTokens: config.maxTokens,
+      options: config.options,
+    });
+  }
+
+  // Fallback: try conventional npm package names
+  const candidates = [
+    `flowweaver-provider-${config.name}`,
+    `@synergenius/flowweaver-provider-${config.name}`,
+  ];
+
+  for (const candidate of candidates) {
+    try {
+      const { factory, metadata } = await loadExternalProvider(candidate);
+      registry.register(config.name, factory, metadata);
+      return factory({
+        model: config.model,
+        maxTokens: config.maxTokens,
+        options: config.options,
+      });
+    } catch {
+      // Try next candidate
+    }
+  }
+
+  throw new Error(
+    `Unknown provider: ${config.name}\n` +
+    `  Install a provider package: npm install flowweaver-provider-${config.name}\n` +
+    `  Or specify a module path: { "provider": { "name": "${config.name}", "module": "./my-provider.js" } }`,
+  );
+}
+
+export function detectProvider(registry: ProviderRegistry = defaultRegistry): BotProviderConfig {
+  // Check registry metadata for env vars and CLI commands
+  for (const { name, metadata } of registry.list()) {
+    if (metadata.requiredEnvVars) {
+      const allPresent = metadata.requiredEnvVars.every((v) => process.env[v]);
+      if (allPresent) return { name };
+    }
+  }
+
+  for (const { name, metadata } of registry.list()) {
+    if (metadata.detectCliCommand) {
+      try {
+        execFileSync(WHICH_CMD, [metadata.detectCliCommand], { stdio: 'pipe' });
+        return { name };
+      } catch { /* not installed */ }
+    }
+  }
+
+  throw new Error(
+    'No AI provider found. Options:\n' +
+    '  1. Set ANTHROPIC_API_KEY environment variable\n' +
+    '  2. Install Claude CLI: https://docs.anthropic.com/claude-code\n' +
+    '  3. Install GitHub Copilot CLI: https://github.com/features/copilot',
+  );
+}
+
+export class AnthropicAgentProvider implements BotAgentProvider {
+  private model: string;
+  private maxTokens: number;
+  onUsage?: OnUsageCallback;
+
+  constructor(config: BotProviderConfig) {
+    this.model = config.model ?? 'claude-sonnet-4-6';
+    this.maxTokens = config.maxTokens ?? 4096;
+  }
+
+  async decide(request: {
+    agentId: string;
+    context: Record<string, unknown>;
+    prompt: string;
+  }): Promise<Record<string, unknown>> {
+    if (!process.env.ANTHROPIC_API_KEY) {
+      throw new Error(
+        'ANTHROPIC_API_KEY environment variable is required for the Anthropic provider',
+      );
+    }
+
+    const Anthropic = await this.loadSdk();
+    const client = new Anthropic();
+    const systemPrompt = await buildSystemPrompt();
+
+    const contextStr =
+      typeof request.context === 'string'
+        ? request.context
+        : JSON.stringify(request.context, null, 2);
+
+    const response = await client.messages.create({
+      model: this.model,
+      max_tokens: this.maxTokens,
+      system: systemPrompt,
+      messages: [
+        {
+          role: 'user',
+          content: `Context:\n${contextStr}\n\nInstructions:\n${request.prompt}`,
+        },
+      ],
+    });
+
+    if (this.onUsage && response.usage) {
+      this.onUsage(request.agentId, response.model ?? this.model, {
+        inputTokens: response.usage.input_tokens,
+        outputTokens: response.usage.output_tokens,
+        cacheCreationInputTokens: response.usage.cache_creation_input_tokens,
+        cacheReadInputTokens: response.usage.cache_read_input_tokens,
+      });
+    }
+
+    const text =
+      response.content[0].type === 'text' ? response.content[0].text : '';
+    return this.parseJson(text);
+  }
+
+  async *stream(request: {
+    agentId: string;
+    context: Record<string, unknown>;
+    prompt: string;
+  }): AsyncIterable<StreamChunk> {
+    if (!process.env.ANTHROPIC_API_KEY) {
+      throw new Error('ANTHROPIC_API_KEY environment variable is required for the Anthropic provider');
+    }
+
+    const Anthropic = await this.loadSdk();
+    const client = new Anthropic();
+    const systemPrompt = await buildSystemPrompt();
+
+    const contextStr = typeof request.context === 'string'
+      ? request.context
+      : JSON.stringify(request.context, null, 2);
+
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const stream = (client as any).messages.stream({
+      model: this.model,
+      max_tokens: this.maxTokens,
+      system: systemPrompt,
+      messages: [{ role: 'user', content: `Context:\n${contextStr}\n\nInstructions:\n${request.prompt}` }],
+    });
+
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    for await (const event of stream as AsyncIterable<any>) {
+      if (event.type === 'content_block_delta' && event.delta?.type === 'text_delta') {
+        yield { type: 'text', text: event.delta.text };
+      }
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const finalMessage = await (stream as any).finalMessage();
+    if (finalMessage?.usage) {
+      const usage = {
+        inputTokens: finalMessage.usage.input_tokens,
+        outputTokens: finalMessage.usage.output_tokens,
+        cacheCreationInputTokens: finalMessage.usage.cache_creation_input_tokens,
+        cacheReadInputTokens: finalMessage.usage.cache_read_input_tokens,
+      };
+      if (this.onUsage) this.onUsage(request.agentId, finalMessage.model ?? this.model, usage);
+      yield { type: 'usage', usage };
+    }
+    yield { type: 'done' };
+  }
+
+  async decideWithTools(request: {
+    agentId: string;
+    context: Record<string, unknown>;
+    prompt: string;
+    tools: ToolDefinition[];
+  }): Promise<{ result: Record<string, unknown>; toolCalls?: ToolUseResult[] }> {
+    if (!process.env.ANTHROPIC_API_KEY) {
+      throw new Error('ANTHROPIC_API_KEY environment variable is required for the Anthropic provider');
+    }
+
+    const Anthropic = await this.loadSdk();
+    const client = new Anthropic();
+    const systemPrompt = await buildSystemPrompt();
+
+    const contextStr = typeof request.context === 'string'
+      ? request.context
+      : JSON.stringify(request.context, null, 2);
+
+    const response = await client.messages.create({
+      model: this.model,
+      max_tokens: this.maxTokens,
+      system: systemPrompt,
+      messages: [{ role: 'user', content: `Context:\n${contextStr}\n\nInstructions:\n${request.prompt}` }],
+      tools: request.tools,
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    } as any);
+
+    if (this.onUsage && response.usage) {
+      this.onUsage(request.agentId, response.model ?? this.model, {
+        inputTokens: response.usage.input_tokens,
+        outputTokens: response.usage.output_tokens,
+        cacheCreationInputTokens: response.usage.cache_creation_input_tokens,
+        cacheReadInputTokens: response.usage.cache_read_input_tokens,
+      });
+    }
+
+    const toolCalls: ToolUseResult[] = [];
+    let text = '';
+    for (const block of response.content) {
+      if (block.type === 'text') text = block.text;
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      else if (block.type === 'tool_use') toolCalls.push({ toolName: (block as any).name, toolInput: (block as any).input });
+    }
+
+    return { result: this.parseJson(text || '{}'), toolCalls: toolCalls.length > 0 ? toolCalls : undefined };
+  }
+
+  private parseJson(text: string): Record<string, unknown> {
+    let cleaned = text.trim();
+    if (cleaned.startsWith('```')) {
+      cleaned = cleaned.replace(/^```(?:json)?\s*\n?/, '').replace(/\n?```\s*$/, '');
+    }
+
+    try {
+      return JSON.parse(cleaned);
+    } catch {
+      const match = cleaned.match(/\{[\s\S]*\}/);
+      if (match) {
+        return JSON.parse(match[0]);
+      }
+      throw new Error(`Failed to parse AI response as JSON: ${text.slice(0, 200)}`);
+    }
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  private async loadSdk(): Promise<new () => any> {
+    try {
+      // @ts-expect-error -- optional peer dep, loaded at runtime
+      const mod = await import('@anthropic-ai/sdk');
+      return mod.default ?? mod.Anthropic;
+    } catch {
+      throw new Error(
+        'Bot mode requires @anthropic-ai/sdk. Install it:\n  npm install @anthropic-ai/sdk',
+      );
+    }
+  }
+}

package/src/bot/ai-client.ts

@@ -0,0 +1,109 @@
+import { execSync, spawn } from 'node:child_process';
+import { parseStreamLine, extractTextFromChunks } from './cli-stream-parser.js';
+import type { StreamChunk } from './types.js';
+
+// Strip CLAUDECODE from child env so nested claude CLI invocations work.
+const childEnv = { ...process.env };
+delete childEnv.CLAUDECODE;
+
+export function callCli(provider: string, prompt: string, model?: string): string {
+  if (provider === 'claude-cli') {
+    const modelFlag = model ? ` --model ${model}` : '';
+    return execSync(`claude -p --output-format text${modelFlag}`, {
+      input: prompt, encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'], timeout: 300_000, env: childEnv,
+    }).trim();
+  }
+  if (provider === 'copilot-cli') {
+    return execSync('copilot -p --silent --allow-all-tools', {
+      input: prompt, encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'], timeout: 300_000, env: childEnv,
+    }).trim();
+  }
+  throw new Error(`Unknown CLI provider: ${provider}`);
+}
+
+export async function callCliAsync(provider: string, prompt: string, model?: string): Promise<string> {
+  if (provider === 'copilot-cli') {
+    return callCli(provider, prompt, model);
+  }
+  if (provider !== 'claude-cli') {
+    throw new Error(`Unknown CLI provider: ${provider}`);
+  }
+
+  const args = ['-p', '--output-format', 'stream-json'];
+  if (model) args.push('--model', model);
+
+  const child = spawn('claude', args, {
+    stdio: ['pipe', 'pipe', 'pipe'],
+    env: childEnv,
+  });
+
+  child.stdin.write(prompt);
+  child.stdin.end();
+
+  const timeout = setTimeout(() => child.kill('SIGTERM'), 300_000);
+
+  const chunks: StreamChunk[] = [];
+  let buffer = '';
+
+  try {
+    for await (const data of child.stdout) {
+      buffer += data.toString();
+      const lines = buffer.split('\n');
+      buffer = lines.pop()!;
+
+      for (const line of lines) {
+        const chunk = parseStreamLine(line);
+        if (chunk) chunks.push(chunk);
+      }
+    }
+
+    if (buffer.trim()) {
+      const chunk = parseStreamLine(buffer);
+      if (chunk) chunks.push(chunk);
+    }
+  } finally {
+    clearTimeout(timeout);
+  }
+
+  await new Promise<void>((resolve, reject) => {
+    child.on('close', (code) => {
+      if (code && code !== 0) reject(new Error(`claude CLI exited with code ${code}`));
+      else resolve();
+    });
+    child.on('error', reject);
+  });
+
+  return extractTextFromChunks(chunks);
+}
+
+export async function callApi(
+  apiKey: string, model: string, maxTokens: number,
+  systemPrompt: string, userPrompt: string,
+): Promise<string> {
+  const body = JSON.stringify({
+    model, max_tokens: maxTokens, system: systemPrompt,
+    messages: [{ role: 'user', content: userPrompt }],
+  });
+  const response = await fetch('https://api.anthropic.com/v1/messages', {
+    method: 'POST',
+    headers: { 'x-api-key': apiKey, 'anthropic-version': '2023-06-01', 'content-type': 'application/json' },
+    body,
+  });
+  if (!response.ok) {
+    const text = await response.text();
+    throw new Error(`Anthropic API error ${response.status}: ${text.slice(0, 200)}`);
+  }
+  const json = await response.json() as { content: Array<{ type: string; text: string }> };
+  return json.content[0]?.text ?? '';
+}
+
+export function parseJsonResponse(text: string): Record<string, unknown> {
+  let cleaned = text.trim();
+  if (cleaned.startsWith('```')) {
+    cleaned = cleaned.replace(/^```(?:json)?\s*\n?/, '').replace(/\n?```\s*$/, '');
+  }
+  try { return JSON.parse(cleaned); } catch { /* fallthrough */ }
+  const match = cleaned.match(/\{[\s\S]*\}/);
+  if (match) return JSON.parse(match[0]);
+  throw new Error(`Failed to parse AI response as JSON: ${text.slice(0, 200)}`);
+}