@agentlang/agentmanager 0.0.3

package/libs/agentcraft/src/prompts/resolver.prompt.ts

@@ -0,0 +1,364 @@
+import { parseAssemblyOutput } from '../utils/output-writer';
+
+/**
+ * Converts a resolver name to a camelCase import alias.
+ * e.g. "github" -> "githubResolver", "github-issues" -> "githubIssuesResolver"
+ */
+function toResolverAlias(name: string): string {
+  const camelCase = name.replace(/-([a-z])/g, (_, c: string) =>
+    c.toUpperCase(),
+  );
+  return camelCase + 'Resolver';
+}
+
+/**
+ * Builds the system prompt for resolver generation.
+ */
+export function buildResolverSystemPrompt(
+  name: string,
+  description: string,
+  specContent: string,
+): string {
+  const filePrefix = name.replace(/-/g, '_') + '_resolver';
+  const jsFileName = filePrefix + '.js';
+  const alFileName = filePrefix + '.al';
+  const importAlias = toResolverAlias(name);
+
+  return `You are a resolver generator for agentlang applications. Your task is to generate a complete resolver package that allows agentlang entities to interact with an external API.
+
+## Resolver Name
+${name}
+
+## Description
+${description}
+
+## API Specification
+<api-spec>
+${specContent}
+</api-spec>
+
+## Agentlang Resolver Syntax Reference
+
+### Entity Definition (.al file)
+Entities are defined using the \`entity\` keyword inside a \`module\` block. Each entity has typed attributes and a \`resolver\` block that maps CRUD operations to functions imported from a JavaScript file. Each resolver block MUST have a unique name (NOT the entity name itself) and a **paths vector** \`[ModuleName/EntityName]\` that specifies which entity it resolves.
+
+Attribute types: \`String\`, \`Int\`, \`Float\`, \`Boolean\`, \`UUID\`, \`DateTime\`, \`Map\`
+Attribute properties: \`@id\` (primary key), \`@unique\`, \`@optional\`, \`@default(value)\`
+
+Attributes may also be declared as arrays, e.g String[].
+
+**Structures with no attributes MUST be defined with \`{}\`**. For example: \`@public event getAllPets {}\`, \`record EmptyPayload {}\`. Never omit the braces.
+
+**IMPORTANT — Resolver binding syntax:**
+
+The .al file MUST import the JavaScript file using an \`import\` statement with \`@as\` to create an alias. Resolver methods are then bound using \`alias.functionName\` (dot notation, NO quotes).
+
+\`\`\`
+module Resolvers.GitHub
+
+import "github_resolver.js" @as githubResolver
+
+entity Issue {
+    id        Int    @id,
+    title     String,
+    body      String @optional,
+    state     String @optional,
+    number    Int    @optional,
+    repo      String,
+    owner     String
+}
+
+resolver IssueResolver [Resolvers.GitHub/Issue] {
+    create  githubResolver.createIssue,
+    query   githubResolver.queryIssue,
+    update  githubResolver.updateIssue,
+    delete  githubResolver.deleteIssue
+}
+\`\`\`
+
+CRITICAL syntax rules:
+- Do NOT use the string-path format like \`"resolver.js/functionName"\`. That is INVALID. Always use \`import "file.js" @as alias\` at the top of the module, then \`alias.functionName\` in resolver blocks.
+- The resolver name MUST be a unique identifier (e.g. \`IssueResolver\`), NOT the entity name itself. \`resolver Issue { ... }\` is WRONG — use \`resolver IssueResolver [GitHub/Issue] { ... }\`.
+- The paths vector \`[ModuleName/EntityName]\` is REQUIRED. It tells agentlang which entity this resolver handles. The ModuleName is the last segment of the module name (e.g. for \`module Resolvers.GitHub\`, use \`GitHub/Issue\`).
+- Resolver method bindings MUST be separated by commas.
+
+### Resolver JS Implementation (${jsFileName})
+The resolver JS file exports functions for each CRUD operation. Each function receives an \`attributes\` object.
+
+- Use \`instance.attributes.get("fieldName")\` to read entity attribute values
+- Use \`instance.queryAttributes.get("fieldName")\` to get values to query entity instances
+- Use \`process.env.ENV_VAR_NAME\` to read environment variables (for auth tokens, API keys, etc.). Do NOT import \`getLocalEnv\` or similar abstractions from agentlang.
+- Use the global \`fetch\` API for HTTP calls
+- Return result objects matching the entity shape
+- Throw errors with descriptive messages on failure
+
+\`\`\`javascript
+async function createIssue(_, instance) { // the first argument '_' is always required for resolver methods
+    const token = process.env.GITHUB_TOKEN;
+    const owner = instance.attributes.get("owner");
+    const repo = instance.attributes.get("repo");
+    const title = instance.attributes.get("title");
+    const body = instance.attributes.get("body");
+
+    const response = await fetch(
+        \`https://api.github.com/repos/\${owner}/\${repo}/issues\`,
+        {
+            method: "POST",
+            headers: {
+                "Authorization": \`Bearer \${token}\`,
+                "Accept": "application/vnd.github+json",
+                "Content-Type": "application/json"
+            },
+            body: JSON.stringify({ title, body })
+        }
+    );
+
+    if (!response.ok) {
+        const error = await response.text();
+        throw new Error(\`GitHub API error: \${response.status} \${error}\`);
+    }
+
+    const issue = await response.json();
+    return {
+        id: issue.id,
+        number: issue.number,
+        title: issue.title,
+        body: issue.body,
+        state: issue.state,
+        repo,
+        owner
+    }
+}
+
+async function queryIssue(_, instance) {
+    const token = process.env.GITHUB_TOKEN;
+    const owner = instance.queryAttributes.get("owner");
+    const repo = instance.queryAttributes.get("repo");
+
+    const response = await fetch(
+        \`https://api.github.com/repos/\${owner}/\${repo}/issues\`,
+        {
+            headers: {
+                "Authorization": \`Bearer \${token}\`,
+                "Accept": "application/vnd.github+json"
+            }
+        }
+    );
+
+    if (!response.ok) {
+        const error = await response.text();
+        throw new Error(\`GitHub API error: \${response.status} \${error}\`);
+    }
+
+    const issues = await response.json();
+    return issues.map(issue => ({
+        id: issue.id,
+        number: issue.number,
+        title: issue.title,
+        body: issue.body,
+        state: issue.state,
+        repo,
+        owner
+    }));
+}
+
+async function updateIssue(_, instance) {
+    const token = process.env.GITHUB_TOKEN;
+    const owner = instance.attributes.get("owner");
+    const repo = instance.attributes.get("repo");
+    const number = instance.attributes.get("number");
+    const title = instance.attributes.get("title");
+    const body = instance.attributes.get("body");
+    const state = instance.attributes.get("state");
+
+    const updates = {};
+    if (title) updates.title = title;
+    if (body) updates.body = body;
+    if (state) updates.state = state;
+
+    const response = await fetch(
+        \`https://api.github.com/repos/\${owner}/\${repo}/issues/\${number}\`,
+        {
+            method: "PATCH",
+            headers: {
+                "Authorization": \`Bearer \${token}\`,
+                "Accept": "application/vnd.github+json",
+                "Content-Type": "application/json"
+            },
+            body: JSON.stringify(updates)
+        }
+    );
+
+    if (!response.ok) {
+        const error = await response.text();
+        throw new Error(\`GitHub API error: \${response.status} \${error}\`);
+    }
+
+    const issue = await response.json();
+    return {
+        id: issue.id,
+        number: issue.number,
+        title: issue.title,
+        body: issue.body,
+        state: issue.state,
+        repo,
+        owner
+    };
+}
+
+async function deleteIssue(_, instance) {
+    const token = process.env.GITHUB_TOKEN;
+    const owner = instance.attributes.get("owner");
+    const repo = instance.attributes.get("repo");
+    const number = instance.attributes.get("number");
+
+    // GitHub API doesn't support deleting issues, so we close it instead
+    const response = await fetch(
+        \`https://api.github.com/repos/\${owner}/\${repo}/issues/\${number}\`,
+        {
+            method: "PATCH",
+            headers: {
+                "Authorization": \`Bearer \${token}\`,
+                "Accept": "application/vnd.github+json",
+                "Content-Type": "application/json"
+            },
+            body: JSON.stringify({ state: "closed" })
+        }
+    );
+
+    if (!response.ok) {
+        const error = await response.text();
+        throw new Error(\`GitHub API error: \${response.status} \${error}\`);
+    }
+
+    return { id: 0, title: "", repo, owner };
+}
+
+export { createIssue, queryIssue, updateIssue, deleteIssue };
+\`\`\`
+
+### package.json
+\`\`\`json
+{
+    "name": "${name}-resolver",
+    "version": "0.1.0",
+    "type": "module"
+}
+\`\`\`
+
+## Output Format
+
+Output exactly three files using this delimiter format:
+
+\`\`\`
+--- FILE: src/${alFileName} ---
+<module definition with import statement and entities with resolver mappings>
+
+--- FILE: src/${jsFileName} ---
+<JavaScript implementation with CRUD functions>
+
+--- FILE: package.json ---
+<package.json with name, version, type>
+\`\`\`
+
+## Reserved Words — Do NOT Use as Names
+
+Agentlang reserves certain keywords. You MUST NOT use any of the following as entity names or attribute names. If your domain has a concept that matches a reserved word, rename it (e.g. \`Event\` → \`CalendarEvent\`, \`Flow\` → \`AppFlow\`, \`Agent\` → \`AIAgent\`, \`import\` → \`importItem\`, \`delete\` → \`isDeleted\`, \`record\` → \`entry\`).
+
+**Definition keywords:** \`module\`, \`import\`, \`entity\`, \`event\`, \`record\`, \`relationship\`, \`workflow\`, \`agent\`, \`resolver\`, \`flow\`, \`decision\`, \`scenario\`, \`directive\`, \`glossaryEntry\`, \`eval\`
+
+**Control flow and operators:** \`if\`, \`else\`, \`for\`, \`in\`, \`return\`, \`throw\`, \`await\`, \`delete\`, \`purge\`, \`case\`, \`not\`, \`true\`, \`false\`, \`or\`, \`and\`, \`like\`, \`between\`
+
+**CRUD and schema keywords:** \`create\`, \`update\`, \`query\`, \`upsert\`, \`contains\`, \`extends\`, \`where\`, \`roles\`, \`allow\`, \`subscribe\`, \`backoff\`, \`attempts\`
+
+## Guidelines
+- Focus on the described functionality: "${description}"
+- Handle authentication via environment variables using \`process.env\` (e.g. \`process.env.PETSTORE_API_KEY\`). Do NOT import \`getLocalEnv\` or similar abstractions from agentlang.
+- Use the global \`fetch\` API for all HTTP requests
+- Include proper error handling with descriptive error messages
+- Map API responses back to entity attribute shapes
+- Module name should follow the pattern \`Resolvers.<PascalCaseName>\`
+- Each entity needs a matching resolver block with a unique resolver name (e.g. \`PetResolver\`, \`OrderResolver\`) and a paths vector \`[ModuleName/EntityName]\`. Resolver method bindings must be comma-separated
+- Export all resolver functions from ${jsFileName}
+- The .al file MUST start with \`import "${jsFileName}" @as ${importAlias}\` right after the module declaration
+- Resolver methods MUST use \`${importAlias}.functionName\` (dot notation), NEVER \`"file/function"\` string syntax`;
+}
+
+export interface PipelineResolverResult {
+  al: string;
+  js: string;
+  meta: string;
+  rawOutput: string;
+}
+
+/**
+ * Parses LLM output with `--- FILE: ---` delimiters into resolver content.
+ * Extracts .al and .js files, and builds metadata from the .al content.
+ */
+export function parseResolverOutput(
+  rawOutput: string,
+): PipelineResolverResult | null {
+  const files = parseAssemblyOutput(rawOutput);
+
+  let al = '';
+  let js = '';
+
+  for (const file of files) {
+    if (file.filePath.endsWith('.al')) {
+      al = file.content;
+    } else if (file.filePath.endsWith('.js')) {
+      js = file.content;
+    }
+  }
+
+  if (!al && !js) {
+    return null;
+  }
+
+  const meta = buildResolverMeta(al);
+
+  return { al, js, meta, rawOutput };
+}
+
+/**
+ * Builds structured metadata from .al content for LLM prompts.
+ * Extracts module name, entity names, and their attributes.
+ */
+export function buildResolverMeta(alContent: string): string {
+  const lines: string[] = ['# Resolver Metadata', ''];
+
+  // Extract module name
+  const moduleMatch = alContent.match(/^module\s+(\S+)/m);
+  if (moduleMatch) {
+    lines.push(`Module: ${moduleMatch[1]}`);
+    lines.push('');
+  }
+
+  // Extract entities and their attributes
+  const entityRe = /entity\s+(\w+)\s*\{([^}]*)\}/g;
+  let match;
+  while ((match = entityRe.exec(alContent)) !== null) {
+    const entityName = match[1];
+    const body = match[2];
+    lines.push(`## Entity: ${entityName}`);
+
+    // Extract attributes: name Type [properties]
+    const attrRe =
+      /(\w+)\s+(String|Int|Float|Boolean|UUID|DateTime|Map|Any|Number|Decimal|Email|Date|Time|URL|Password)(?:\[\])?\s*([^,\n]*)/g;
+    let attrMatch;
+    const attrs: string[] = [];
+    while ((attrMatch = attrRe.exec(body)) !== null) {
+      attrs.push(
+        `- ${attrMatch[1]}: ${attrMatch[2]}${attrMatch[3].trim() ? ' ' + attrMatch[3].trim() : ''}`,
+      );
+    }
+    if (attrs.length > 0) {
+      lines.push('Attributes:');
+      lines.push(...attrs);
+    }
+
+    lines.push('');
+  }
+
+  return lines.join('\n').trim();
+}

package/libs/agentcraft/src/prompts/semantics-guide.ts

@@ -0,0 +1,134 @@
+/**
+ * Agentlang semantics guide — a focused conceptual reference for the LLM
+ * during the design phase. Explains what each construct means, when to use
+ * it, and how constructs compose into a system.
+ *
+ * This is NOT a syntax reference — no code examples, no grammar rules.
+ * The goal is to teach the LLM to make correct architectural decisions.
+ */
+export const SEMANTICS_GUIDE = `## Agentlang Semantics Guide
+
+Agentlang is a declarative language for building AI-powered applications. An application is a **module** containing entities, relationships, events, workflows, and agents. Understanding when to use each construct is critical for correct design.
+
+### Entity
+
+An entity is a **persistent, database-backed domain object**. Every noun in your domain that needs to be stored, queried, or referenced is an entity. Examples: User, Product, Order, Lead, Ticket.
+
+At design time, define entities with a name and description only — attributes are added during code generation. Focus on identifying the right set of entities: too few leads to overloaded entities; too many leads to unnecessary complexity.
+
+**When to define an entity:** Any domain concept that has its own identity and lifecycle, needs CRUD operations, or is referenced by other constructs.
+
+**When NOT to define an entity:** Temporary data, computed values, or concepts that only exist within a single workflow step.
+
+**Inheritance:** An entity can extend a record or another entity to inherit its attributes. Use when multiple entities share a common set of fields.
+
+**Entity-level features** (important design decisions — mark which ones apply to each entity):
+
+- **@meta {"audit": true}** — Enable audit trail. Use when you need to track who changed what and when (e.g., compliance-sensitive entities like Orders, Payments, MedicalRecords).
+- **@meta {"fullTextSearch": "\*"}** — Enable full-text search. Use when users need to search entity instances by free-text queries (e.g., Tickets, Articles, Products).
+- **@rbac** — Role-based access control at the entity level. Define which roles can create/read/update/delete, and optional row-level filters (e.g., "users can only read their own records"). Use when different user roles need different access levels.
+- **@before/@after triggers** — Lifecycle hooks that fire before or after create/update/delete operations. Use when an entity change should automatically trigger side effects (e.g., after creating a Ticket, auto-assign it; before updating an Order, validate inventory). Triggers reference events/workflows by name and can be @async.
+- **@with_unique(attr1, attr2)** — Composite unique constraint across multiple attributes. Use when no single attribute is unique but the combination must be (e.g., unique email per organization, unique document per version).
+- **@actions** — Bind named actions to events on an entity. Use when an entity needs custom operations beyond standard CRUD.
+- **@expr** — Computed attributes whose values are automatically derived from other fields. Use when a field's value can always be calculated from other attributes (e.g., totalPrice = quantity * unitPrice). User-provided values override the computed expression.
+
+### Relationship
+
+Relationships connect entities. There are exactly two kinds — choosing the right one is a critical design decision.
+
+**contains (parent-child ownership):**
+- The parent **owns** the child. The child's identity is scoped within the parent.
+- Deleting the parent cascades to delete all children.
+- The child has no meaning outside its parent.
+- Use for: Orders containing OrderItems, Users containing Posts, Projects containing Tasks.
+
+**between (cross-reference association):**
+- Both entities have **independent lifecycles**. Neither owns the other.
+- Deleting one side does NOT delete the other.
+- Supports cardinality: one_one, one_many (default is many-to-many).
+- Use for: Students enrolled in Courses, Employees assigned to Departments, Tags on Articles.
+
+**Decision framework:** Ask "If I delete entity A, should entity B also be deleted?" If yes → contains. If no → between.
+
+**Cardinality for between relationships:**
+- one_one: Each A has exactly one B, and vice versa (e.g., User ↔ Profile).
+- one_many: Each A has many Bs, but each B belongs to one A (e.g., Department → Employees).
+- many_many (default): Each A can relate to many Bs and vice versa (e.g., Students ↔ Courses).
+
+**Role aliases (@as):** When a relationship connects an entity to itself (self-referencing), use @as to distinguish the two roles. Example: Employee @as manager ↔ Employee @as report. Use when modeling hierarchies, mentorship, or any self-referential relationship.
+
+**Relationship schemas:** A relationship can carry its own attributes (e.g., Enrollment between Student and Course might have enrolledOn and grade). Use when the association itself has data beyond just linking two entities.
+
+### Event
+
+An event is a **command or action** that triggers a workflow. It defines the input data schema for that action.
+
+- @public events expose a REST API endpoint (POST /api/Module/EventName).
+- Events can extend a record or another event to inherit attributes.
+- Events represent user actions (SubmitOrder, ApproveApplication) or system triggers (ProcessPayment, SendNotification).
+- Event names should clearly describe the action being performed.
+
+**When to define an event:** Any action that initiates a process, changes state, or triggers side effects.
+
+### Workflow
+
+A workflow is the **procedural handler** for an event or a lifecycle trigger. It performs CRUD operations on entities, invokes agents, and orchestrates multi-step logic.
+
+**Two forms:**
+
+1. **Event-driven (named):** The workflow name matches the event name. When the event fires, the workflow executes.
+2. **Lifecycle trigger:** Fires automatically before or after an entity's create, update, or delete operation. Use for automatic side effects (e.g., after creating a User, create a default Profile; before deleting an Order, check it's not shipped).
+
+**Access control:** @withRole restricts who can invoke a workflow (e.g., only admins can run an approval workflow).
+
+**What workflows can do:**
+- **CRUD operations** — Create, query (with ? suffix), update, upsert, delete, and purge entity instances.
+- **Sequential binding** — Chain operations with @as to bind results to variables for subsequent steps.
+- **Control flow** — if/else conditionals and for-each loops over collections.
+- **Error handling** — @catch for not_found and error cases; @empty for handling empty query results with fallback logic.
+- **Side effects** — @then for post-operation logic (run additional statements after a create/update).
+- **Joins and analytics** — Query across entities with @join/@left_join/@right_join/@full_join, project results with @into, filter with @where, aggregate with @count/@sum/@avg/@min/@max, group with @groupBy, sort with @orderBy, paginate with @limit/@offset, deduplicate with @distinct.
+- **Upsert** — @upsert for create-or-update semantics.
+- **Full-text search** — Query entities using free-text when @meta fullTextSearch is enabled.
+- **Return and throw** — Return results or throw errors to abort with a message.
+
+**When to define a workflow:** Every event needs a corresponding workflow. Lifecycle triggers are for automatic side effects on entity operations. The workflow describes WHAT happens — which entities are read, created, updated, or deleted.
+
+### Agent
+
+An agent is an **AI-powered component** using an LLM. Agents understand natural language, make decisions, classify data, generate content, and interact with entities via tools.
+
+- Tools are the entities, events, and workflows an agent can call.
+- @public agents expose a REST chat endpoint.
+- Each agent should have a focused role — one agent per domain area.
+
+**When to define an agent:** Any task requiring natural language understanding, classification, content generation, or intelligent decision-making. Agents are NOT needed for simple CRUD — workflows handle that directly.
+
+**Agent goal:** Each agent should have a clear high-level objective explaining its purpose in the system. The goal answers "why does this agent exist and what value does it provide?"
+
+**Key agent capabilities** (design decisions — note which ones each agent needs):
+
+- **responseSchema** — Force the agent to return structured output matching a record type. Use when downstream code needs to process the agent's output programmatically (e.g., a classification agent returning a typed result).
+- **documents** — Attach documents for RAG (retrieval-augmented generation). Use when the agent needs access to reference material (e.g., product manuals, pricing lists, policy documents).
+- **validate** — Run a validation workflow on the agent's output before accepting it. Use when the agent's output must meet specific business rules.
+- **retry** — Retry policy for failed agent invocations. Use when the agent's task is critical and transient failures are possible.
+- **stateless** — If true, the agent has no conversation history. Use for one-shot classification or transformation tasks that don't need context from previous interactions.
+- **scratch** — Temporary mutable variables available during the agent's execution. Use when the agent needs working memory across tool calls within a single interaction.
+- **compact** — Number of conversation turns before older messages are summarized and discarded. Use for long-running agents to prevent context overflow.
+
+### Flow (Advanced)
+
+A flow is an **orchestration pipeline** connecting multiple agents and decision points. Use when a complex process requires sequential agent invocations with routing logic.
+
+**When to define a flow:** Multi-step AI processes where one agent's output feeds another, with conditional routing between them. Most applications don't need flows — they are for complex orchestration scenarios.
+
+### How Constructs Compose
+
+The typical pattern is:
+1. **Entities** hold the data (the nouns)
+2. **Relationships** define how entities connect
+3. **Events** represent actions users or systems can take (the verbs)
+4. **Workflows** handle events by reading/writing entities
+5. **Agents** add intelligence — they are invoked by workflows when AI reasoning is needed
+6. **Flows** orchestrate multiple agents for complex multi-step AI processes
+`;

package/libs/agentcraft/src/services/anthropic-craft-llm.service.ts

@@ -0,0 +1,186 @@
+import { Injectable } from '@nestjs/common';
+import Anthropic from '@anthropic-ai/sdk';
+import { CraftLlmProvider } from '../interfaces/llm-provider.interface';
+import { ChatRequest, ChatResponse, ToolCall } from '../types/llm.types';
+
+@Injectable()
+export class AnthropicCraftLlmService implements CraftLlmProvider {
+  private client: Anthropic;
+  private model: string;
+  private maxRetries = 3;
+  private baseDelay = 1000;
+
+  constructor(model: string, apiKey: string) {
+    this.client = new Anthropic({ apiKey });
+    this.model = model;
+  }
+
+  async chat(request: ChatRequest): Promise<ChatResponse> {
+    return this.withRetry(async () => {
+      const useCache = request.cacheControl ?? false;
+
+      const params: Anthropic.MessageCreateParams = {
+        model: this.model,
+        max_tokens: request.maxTokens ?? 16384,
+        system: useCache
+          ? [
+              {
+                type: 'text' as const,
+                text: request.system,
+                cache_control: { type: 'ephemeral' as const },
+              },
+            ]
+          : request.system,
+        messages: request.messages.map((m) => ({
+          role: m.role,
+          content:
+            typeof m.content === 'string'
+              ? m.content
+              : m.content
+                  .filter(
+                    (b): b is { type: 'text'; text: string } =>
+                      b.type === 'text',
+                  )
+                  .map((b) => b.text)
+                  .join(''),
+        })),
+      };
+
+      if (request.tools?.length) {
+        params.tools = request.tools.map((t, i) => ({
+          name: t.name,
+          description: t.description ?? '',
+          input_schema: t.inputSchema as Anthropic.Tool.InputSchema,
+          ...(useCache && i === request.tools!.length - 1
+            ? { cache_control: { type: 'ephemeral' as const } }
+            : {}),
+        }));
+      }
+
+      if (request.toolChoice) {
+        params.tool_choice = {
+          type: 'tool' as const,
+          name: request.toolChoice.name,
+        };
+      }
+
+      // Use streaming to avoid the SDK's 10-minute timeout guard
+      const stream = this.client.messages.stream(params);
+      for await (const event of stream) {
+        // consume events to drive the stream
+        void event;
+      }
+      const response = await stream.finalMessage();
+
+      const content = response.content
+        .filter((block) => block.type === 'text')
+        .map((block) => (block as Anthropic.TextBlock).text)
+        .join('');
+
+      const toolCalls: ToolCall[] = response.content
+        .filter(
+          (block): block is Anthropic.ToolUseBlock => block.type === 'tool_use',
+        )
+        .map((block) => ({
+          id: block.id,
+          name: block.name,
+          input: block.input,
+        }));
+
+      return {
+        content: [{ type: 'text', text: content }],
+        stopReason:
+          response.stop_reason === 'max_tokens' ? 'max_tokens' : 'end_turn',
+        toolCalls: toolCalls.length > 0 ? toolCalls : undefined,
+        truncated: response.stop_reason === 'max_tokens',
+        usage: {
+          inputTokens: response.usage.input_tokens,
+          outputTokens: response.usage.output_tokens,
+          cacheCreationInputTokens:
+            response.usage.cache_creation_input_tokens ?? undefined,
+          cacheReadInputTokens:
+            response.usage.cache_read_input_tokens ?? undefined,
+        },
+      };
+    });
+  }
+
+  async chatStream(
+    request: ChatRequest,
+    onChunk: (text: string) => void,
+  ): Promise<ChatResponse> {
+    return this.withRetry(async () => {
+      const stream = this.client.messages.stream({
+        model: this.model,
+        max_tokens: request.maxTokens ?? 16384,
+        system: request.system,
+        messages: request.messages.map((m) => ({
+          role: m.role,
+          content:
+            typeof m.content === 'string'
+              ? m.content
+              : m.content
+                  .filter(
+                    (b): b is { type: 'text'; text: string } =>
+                      b.type === 'text',
+                  )
+                  .map((b) => b.text)
+                  .join(''),
+        })),
+      });
+
+      let fullContent = '';
+      for await (const event of stream) {
+        if (
+          event.type === 'content_block_delta' &&
+          event.delta.type === 'text_delta'
+        ) {
+          onChunk(event.delta.text);
+          fullContent += event.delta.text;
+        }
+      }
+
+      const finalMessage = await stream.finalMessage();
+      return {
+        content: [{ type: 'text', text: fullContent }],
+        stopReason:
+          finalMessage.stop_reason === 'max_tokens' ? 'max_tokens' : 'end_turn',
+        usage: {
+          inputTokens: finalMessage.usage.input_tokens,
+          outputTokens: finalMessage.usage.output_tokens,
+        },
+      };
+    });
+  }
+
+  private async withRetry<T>(fn: () => Promise<T>): Promise<T> {
+    let lastError: Error | undefined;
+    for (let attempt = 0; attempt < this.maxRetries; attempt++) {
+      try {
+        return await fn();
+      } catch (err) {
+        lastError = err as Error;
+        if (!this.isRetryable(lastError) || attempt === this.maxRetries - 1) {
+          throw lastError;
+        }
+        const delay = this.baseDelay * Math.pow(2, attempt);
+        await new Promise((resolve) => setTimeout(resolve, delay));
+      }
+    }
+    throw lastError;
+  }
+
+  private isRetryable(error: Error): boolean {
+    const message = error.message.toLowerCase();
+    return (
+      message.includes('rate limit') ||
+      message.includes('429') ||
+      message.includes('500') ||
+      message.includes('502') ||
+      message.includes('503') ||
+      message.includes('network') ||
+      message.includes('timeout') ||
+      message.includes('econnreset')
+    );
+  }
+}