agentic-flow 1.9.0 → 1.9.2

package/agentic-flow/docs/guides/IMPLEMENTATION_EXAMPLES.md

@@ -1,960 +0,0 @@
-# Implementation Examples - Production-Ready Code
-
-Complete, production-ready code examples for implementing Claude Agent SDK improvements.
-
-## Example 1: Enhanced Web Research Agent
-
-### Before
-```typescript
-// src/agents/webResearchAgent.ts
-import { query } from "@anthropic-ai/claude-agent-sdk";
-
-export async function webResearchAgent(input: string) {
-  const result = query({
-    prompt: input,
-    options: {
-      systemPrompt: `You perform fast web-style reconnaissance and return a concise bullet list of findings.`
-    }
-  });
-
-  let output = '';
-  for await (const msg of result) {
-    if (msg.type === 'assistant') {
-      output += msg.message.content?.map((c: any) => c.type === 'text' ? c.text : '').join('');
-    }
-  }
-
-  return { output };
-}
-```
-
-### After
-```typescript
-// src/agents/webResearchAgent.ts
-import { query, Options } from "@anthropic-ai/claude-agent-sdk";
-import { logger } from '../utils/logger';
-import { metrics } from '../utils/metrics';
-
-export interface ResearchResult {
-  output: string;
-  sources: string[];
-  tokensUsed: number;
-  costUSD: number;
-  duration: number;
-}
-
-export async function webResearchAgent(input: string): Promise<ResearchResult> {
-  const startTime = Date.now();
-  const sources: string[] = [];
-
-  logger.info('Web research agent starting', { input });
-  metrics.agentExecutions.inc({ agent: 'research', status: 'started' });
-
-  const options: Options = {
-    systemPrompt: `You are a web research specialist. You:
-    1. Use WebSearch to find authoritative sources
-    2. Use WebFetch to analyze source content
-    3. Synthesize findings into a concise bullet list
-    4. Cite all sources used
-    5. Focus on recent, reliable information`,
-
-    allowedTools: [
-      'WebSearch',
-      'WebFetch',
-      'FileRead',   // Can read existing research
-      'FileWrite'   // Can save findings
-    ],
-
-    maxTurns: 20,
-    model: 'claude-sonnet-4-5-20250929',
-
-    hooks: {
-      PreToolUse: [{
-        hooks: [async (hookInput) => {
-          logger.debug('Tool use starting', {
-            tool: hookInput.tool_name,
-            input: hookInput.tool_input
-          });
-
-          if (hookInput.tool_name === 'WebFetch') {
-            const url = (hookInput.tool_input as any).url;
-            sources.push(url);
-          }
-
-          return { continue: true };
-        }]
-      }],
-
-      PostToolUse: [{
-        hooks: [async (hookInput) => {
-          logger.debug('Tool use completed', {
-            tool: hookInput.tool_name,
-            success: !hookInput.tool_response?.error
-          });
-
-          metrics.toolExecutions.inc({
-            agent: 'research',
-            tool: hookInput.tool_name,
-            status: hookInput.tool_response?.error ? 'error' : 'success'
-          });
-
-          return { continue: true };
-        }]
-      }]
-    }
-  };
-
-  try {
-    const result = query({ prompt: input, options });
-    let output = '';
-    let finalResult: any = null;
-
-    for await (const message of result) {
-      if (message.type === 'stream_event') {
-        // Real-time streaming for better UX
-        const event = message.event;
-        if (event.type === 'content_block_delta' &&
-            event.delta.type === 'text_delta') {
-          process.stdout.write(event.delta.text);
-          output += event.delta.text;
-        }
-      } else if (message.type === 'assistant') {
-        // Complete assistant message
-        const content = message.message.content
-          ?.map((c: any) => c.type === 'text' ? c.text : '')
-          .join('');
-        output += content;
-      } else if (message.type === 'result') {
-        finalResult = message;
-      }
-    }
-
-    const duration = Date.now() - startTime;
-
-    logger.info('Web research agent completed', {
-      duration,
-      tokensUsed: finalResult?.usage.input_tokens + finalResult?.usage.output_tokens,
-      cost: finalResult?.total_cost_usd
-    });
-
-    metrics.agentExecutions.inc({ agent: 'research', status: 'completed' });
-    metrics.executionDuration.observe({ agent: 'research' }, duration / 1000);
-
-    if (finalResult?.usage) {
-      metrics.tokenUsage.inc({
-        agent: 'research',
-        type: 'input'
-      }, finalResult.usage.input_tokens);
-
-      metrics.tokenUsage.inc({
-        agent: 'research',
-        type: 'output'
-      }, finalResult.usage.output_tokens);
-
-      metrics.costUSD.inc(
-        { agent: 'research' },
-        finalResult.total_cost_usd
-      );
-    }
-
-    return {
-      output: output.trim(),
-      sources,
-      tokensUsed: finalResult?.usage.input_tokens + finalResult?.usage.output_tokens || 0,
-      costUSD: finalResult?.total_cost_usd || 0,
-      duration
-    };
-  } catch (error: any) {
-    logger.error('Web research agent failed', {
-      error: error.message,
-      stack: error.stack
-    });
-
-    metrics.agentExecutions.inc({ agent: 'research', status: 'failed' });
-
-    throw error;
-  }
-}
-```
-
-## Example 2: Resilient Orchestrator
-
-```typescript
-// src/orchestrator/ResilientOrchestrator.ts
-import { webResearchAgent } from '../agents/webResearchAgent';
-import { codeReviewAgent } from '../agents/codeReviewAgent';
-import { dataAgent } from '../agents/dataAgent';
-import { logger } from '../utils/logger';
-import { RetryPolicy } from '../utils/RetryPolicy';
-
-export interface OrchestrationResult {
-  research?: any;
-  review?: any;
-  data?: any;
-  summary: string;
-  totalCost: number;
-  duration: number;
-  failures: string[];
-}
-
-export class ResilientOrchestrator {
-  private retryPolicy: RetryPolicy;
-
-  constructor() {
-    this.retryPolicy = new RetryPolicy({
-      maxRetries: 3,
-      backoffMs: 1000,
-      maxBackoffMs: 30000
-    });
-  }
-
-  async orchestrate(task: string): Promise<OrchestrationResult> {
-    const startTime = Date.now();
-    logger.info('Orchestration started', { task });
-
-    const topic = process.env.TOPIC ?? task;
-    const codeDiff = process.env.DIFF ?? '';
-    const datasetHint = process.env.DATASET ?? '';
-
-    // Execute agents in parallel with retry logic
-    const results = await Promise.allSettled([
-      this.retryPolicy.execute(() =>
-        webResearchAgent(`Give me context and risks about: ${topic}`)
-      ),
-      this.retryPolicy.execute(() =>
-        codeReviewAgent(`Review this at a high level: ${codeDiff || topic}`)
-      ),
-      this.retryPolicy.execute(() =>
-        dataAgent(`Analyze ${datasetHint || topic} and report key stats.`)
-      )
-    ]);
-
-    // Extract results and failures
-    const [researchResult, reviewResult, dataResult] = results;
-
-    const research = researchResult.status === 'fulfilled'
-      ? researchResult.value
-      : null;
-
-    const review = reviewResult.status === 'fulfilled'
-      ? reviewResult.value
-      : null;
-
-    const data = dataResult.status === 'fulfilled'
-      ? dataResult.value
-      : null;
-
-    const failures: string[] = [];
-
-    if (researchResult.status === 'rejected') {
-      logger.error('Research agent failed', {
-        error: researchResult.reason
-      });
-      failures.push(`research: ${researchResult.reason.message}`);
-    }
-
-    if (reviewResult.status === 'rejected') {
-      logger.error('Review agent failed', {
-        error: reviewResult.reason
-      });
-      failures.push(`review: ${reviewResult.reason.message}`);
-    }
-
-    if (dataResult.status === 'rejected') {
-      logger.error('Data agent failed', {
-        error: dataResult.reason
-      });
-      failures.push(`data: ${dataResult.reason.message}`);
-    }
-
-    // Check if at least one agent succeeded
-    if (!research && !review && !data) {
-      throw new Error('All agents failed: ' + failures.join(', '));
-    }
-
-    // Generate summary from available results
-    const summary = this.generateSummary({
-      research,
-      review,
-      data,
-      failures
-    });
-
-    const totalCost = [research, review, data]
-      .filter(Boolean)
-      .reduce((sum, result) => sum + (result?.costUSD || 0), 0);
-
-    const duration = Date.now() - startTime;
-
-    logger.info('Orchestration completed', {
-      duration,
-      totalCost,
-      successfulAgents: [research, review, data].filter(Boolean).length,
-      failedAgents: failures.length
-    });
-
-    return {
-      research,
-      review,
-      data,
-      summary,
-      totalCost,
-      duration,
-      failures
-    };
-  }
-
-  private generateSummary(input: {
-    research?: any;
-    review?: any;
-    data?: any;
-    failures: string[];
-  }): string {
-    const sections: string[] = [];
-
-    if (input.research) {
-      sections.push('=== RESEARCH ===');
-      sections.push(input.research.output);
-      sections.push(`\nSources: ${input.research.sources.join(', ')}`);
-    }
-
-    if (input.review) {
-      sections.push('\n=== CODE REVIEW ===');
-      sections.push(input.review.output);
-    }
-
-    if (input.data) {
-      sections.push('\n=== DATA ANALYSIS ===');
-      sections.push(input.data.output);
-    }
-
-    if (input.failures.length > 0) {
-      sections.push('\n=== WARNINGS ===');
-      sections.push('Some agents failed:');
-      input.failures.forEach(failure => {
-        sections.push(`- ${failure}`);
-      });
-    }
-
-    return sections.join('\n');
-  }
-}
-```
-
-## Example 3: Retry Policy Utility
-
-```typescript
-// src/utils/RetryPolicy.ts
-import { logger } from './logger';
-
-export interface RetryConfig {
-  maxRetries: number;
-  backoffMs: number;
-  maxBackoffMs: number;
-}
-
-export class RetryPolicy {
-  constructor(private config: RetryConfig) {}
-
-  async execute<T>(fn: () => Promise<T>): Promise<T> {
-    let lastError: Error;
-
-    for (let attempt = 0; attempt <= this.config.maxRetries; attempt++) {
-      try {
-        return await fn();
-      } catch (error: any) {
-        lastError = error;
-
-        // Don't retry on last attempt
-        if (attempt === this.config.maxRetries) {
-          throw error;
-        }
-
-        // Check if error is retriable
-        if (!this.isRetriable(error)) {
-          logger.warn('Non-retriable error, not retrying', {
-            error: error.message,
-            code: error.code
-          });
-          throw error;
-        }
-
-        // Calculate exponential backoff
-        const backoff = Math.min(
-          this.config.backoffMs * Math.pow(2, attempt),
-          this.config.maxBackoffMs
-        );
-
-        logger.warn(`Retry attempt ${attempt + 1}/${this.config.maxRetries}`, {
-          error: error.message,
-          backoffMs: backoff,
-          attempt: attempt + 1
-        });
-
-        await this.sleep(backoff);
-      }
-    }
-
-    throw lastError!;
-  }
-
-  private isRetriable(error: any): boolean {
-    const retriableCodes = [
-      'rate_limit_error',
-      'overloaded_error',
-      'timeout_error',
-      'ECONNRESET',
-      'ETIMEDOUT',
-      'ECONNREFUSED'
-    ];
-
-    const retriableStatuses = [429, 500, 502, 503, 504];
-
-    return (
-      retriableCodes.some(code =>
-        error.code === code ||
-        error.message?.toLowerCase().includes(code.toLowerCase())
-      ) ||
-      retriableStatuses.includes(error.status) ||
-      retriableStatuses.includes(error.statusCode)
-    );
-  }
-
-  private sleep(ms: number): Promise<void> {
-    return new Promise(resolve => setTimeout(resolve, ms));
-  }
-}
-```
-
-## Example 4: Structured Logging
-
-```typescript
-// src/utils/logger.ts
-import winston from 'winston';
-
-const logFormat = winston.format.combine(
-  winston.format.timestamp({
-    format: 'YYYY-MM-DD HH:mm:ss'
-  }),
-  winston.format.errors({ stack: true }),
-  winston.format.splat(),
-  winston.format.json()
-);
-
-export const logger = winston.createLogger({
-  level: process.env.LOG_LEVEL || 'info',
-  format: logFormat,
-  defaultMeta: {
-    service: 'claude-agent-orchestrator',
-    version: process.env.npm_package_version || '0.1.0'
-  },
-  transports: [
-    // Console output for development
-    new winston.transports.Console({
-      format: winston.format.combine(
-        winston.format.colorize(),
-        winston.format.simple()
-      )
-    }),
-
-    // File output for production
-    new winston.transports.File({
-      filename: 'logs/error.log',
-      level: 'error',
-      maxsize: 10 * 1024 * 1024, // 10MB
-      maxFiles: 5
-    }),
-
-    new winston.transports.File({
-      filename: 'logs/combined.log',
-      maxsize: 10 * 1024 * 1024, // 10MB
-      maxFiles: 10
-    })
-  ]
-});
-
-// Create logs directory if it doesn't exist
-import { existsSync, mkdirSync } from 'fs';
-if (!existsSync('logs')) {
-  mkdirSync('logs');
-}
-```
-
-## Example 5: Prometheus Metrics
-
-```typescript
-// src/utils/metrics.ts
-import { Registry, Counter, Histogram, Gauge } from 'prom-client';
-
-export const registry = new Registry();
-
-registry.setDefaultLabels({
-  app: 'claude-agent-orchestrator',
-  environment: process.env.NODE_ENV || 'development'
-});
-
-export const metrics = {
-  agentExecutions: new Counter({
-    name: 'agent_executions_total',
-    help: 'Total number of agent executions',
-    labelNames: ['agent', 'status'],
-    registers: [registry]
-  }),
-
-  executionDuration: new Histogram({
-    name: 'agent_execution_duration_seconds',
-    help: 'Agent execution duration in seconds',
-    labelNames: ['agent'],
-    buckets: [0.1, 0.5, 1, 5, 10, 30, 60, 300],
-    registers: [registry]
-  }),
-
-  activeAgents: new Gauge({
-    name: 'agent_active_count',
-    help: 'Number of currently active agents',
-    labelNames: ['agent'],
-    registers: [registry]
-  }),
-
-  tokenUsage: new Counter({
-    name: 'agent_tokens_total',
-    help: 'Total tokens used by agents',
-    labelNames: ['agent', 'type'],
-    registers: [registry]
-  }),
-
-  costUSD: new Counter({
-    name: 'agent_cost_usd_total',
-    help: 'Total cost in USD',
-    labelNames: ['agent'],
-    registers: [registry]
-  }),
-
-  toolExecutions: new Counter({
-    name: 'agent_tool_executions_total',
-    help: 'Total tool executions',
-    labelNames: ['agent', 'tool', 'status'],
-    registers: [registry]
-  }),
-
-  errors: new Counter({
-    name: 'agent_errors_total',
-    help: 'Total number of errors',
-    labelNames: ['agent', 'error_type'],
-    registers: [registry]
-  })
-};
-
-export function getMetrics(): Promise<string> {
-  return registry.metrics();
-}
-```
-
-## Example 6: Health Check Server
-
-```typescript
-// src/server/healthServer.ts
-import express from 'express';
-import { logger } from '../utils/logger';
-import { getMetrics } from '../utils/metrics';
-import { query } from '@anthropic-ai/claude-agent-sdk';
-
-const app = express();
-const port = process.env.HEALTH_PORT || 3000;
-
-app.get('/health', async (req, res) => {
-  const health = {
-    status: 'healthy',
-    timestamp: new Date().toISOString(),
-    version: process.env.npm_package_version || '0.1.0',
-    services: {
-      anthropic: await checkAnthropicAPI(),
-      filesystem: checkFilesystem(),
-      memory: checkMemory()
-    }
-  };
-
-  const allHealthy = Object.values(health.services).every(
-    (s: any) => s.status === 'ok'
-  );
-
-  if (!allHealthy) {
-    health.status = 'degraded';
-  }
-
-  const statusCode = health.status === 'healthy' ? 200 : 503;
-  res.status(statusCode).json(health);
-});
-
-app.get('/metrics', async (req, res) => {
-  try {
-    const metrics = await getMetrics();
-    res.set('Content-Type', 'text/plain');
-    res.send(metrics);
-  } catch (error: any) {
-    logger.error('Failed to get metrics', { error: error.message });
-    res.status(500).json({ error: 'Failed to get metrics' });
-  }
-});
-
-app.get('/ready', (req, res) => {
-  res.json({ ready: true });
-});
-
-async function checkAnthropicAPI(): Promise<any> {
-  try {
-    const startTime = Date.now();
-
-    const result = query({
-      prompt: 'ping',
-      options: {
-        maxTurns: 1,
-        allowedTools: []
-      }
-    });
-
-    for await (const message of result) {
-      if (message.type === 'result') {
-        const duration = Date.now() - startTime;
-
-        return {
-          status: message.is_error ? 'error' : 'ok',
-          latency: duration,
-          error: message.is_error ? message.subtype : null
-        };
-      }
-    }
-
-    return { status: 'error', error: 'No response' };
-  } catch (error: any) {
-    logger.error('Anthropic API health check failed', {
-      error: error.message
-    });
-
-    return {
-      status: 'error',
-      error: error.message
-    };
-  }
-}
-
-function checkFilesystem(): any {
-  try {
-    const fs = require('fs');
-    const path = require('path');
-
-    const testPath = path.join(process.cwd(), '.health-check-test');
-
-    fs.writeFileSync(testPath, 'test');
-    const content = fs.readFileSync(testPath, 'utf-8');
-    fs.unlinkSync(testPath);
-
-    if (content !== 'test') {
-      throw new Error('Filesystem read/write mismatch');
-    }
-
-    return { status: 'ok' };
-  } catch (error: any) {
-    return {
-      status: 'error',
-      error: error.message
-    };
-  }
-}
-
-function checkMemory(): any {
-  const used = process.memoryUsage();
-  const heapUsedMB = used.heapUsed / 1024 / 1024;
-  const heapTotalMB = used.heapTotal / 1024 / 1024;
-  const usagePercent = (heapUsedMB / heapTotalMB) * 100;
-
-  return {
-    status: usagePercent < 90 ? 'ok' : 'warning',
-    heapUsedMB: Math.round(heapUsedMB),
-    heapTotalMB: Math.round(heapTotalMB),
-    usagePercent: Math.round(usagePercent)
-  };
-}
-
-export function startHealthServer() {
-  app.listen(port, () => {
-    logger.info(`Health check server started on port ${port}`);
-  });
-}
-```
-
-## Example 7: Updated Main Entry Point
-
-```typescript
-// src/index.ts
-import "dotenv/config";
-import { ResilientOrchestrator } from './orchestrator/ResilientOrchestrator';
-import { startHealthServer } from './server/healthServer';
-import { logger } from './utils/logger';
-
-async function main() {
-  logger.info('Application starting');
-
-  // Start health check server
-  startHealthServer();
-
-  const topic = process.env.TOPIC ?? "migrate payments service";
-
-  logger.info('Starting orchestration', { topic });
-
-  const orchestrator = new ResilientOrchestrator();
-
-  try {
-    const result = await orchestrator.orchestrate(topic);
-
-    console.log('\n' + '='.repeat(80));
-    console.log(result.summary);
-    console.log('='.repeat(80));
-
-    logger.info('Orchestration summary', {
-      totalCost: result.totalCost,
-      duration: result.duration,
-      failures: result.failures
-    });
-
-    if (result.failures.length > 0) {
-      process.exit(1);
-    }
-  } catch (error: any) {
-    logger.error('Orchestration failed', {
-      error: error.message,
-      stack: error.stack
-    });
-
-    process.exit(1);
-  }
-}
-
-main().catch(err => {
-  logger.error('Unhandled error', {
-    error: err.message,
-    stack: err.stack
-  });
-  process.exit(1);
-});
-```
-
-## Example 8: Updated Package.json
-
-```json
-{
-  "name": "claude-agents-docker",
-  "version": "1.0.0",
-  "private": true,
-  "type": "module",
-  "scripts": {
-    "start": "node --enable-source-maps dist/index.js",
-    "build": "tsc -p .",
-    "dev": "tsx src/index.ts",
-    "test": "vitest",
-    "test:coverage": "vitest --coverage",
-    "lint": "eslint src/**/*.ts",
-    "format": "prettier --write src/**/*.ts"
-  },
-  "dependencies": {
-    "@anthropic-ai/claude-agent-sdk": "^0.1.5",
-    "@anthropic-ai/sdk": "^0.65.0",
-    "dotenv": "^16.4.5",
-    "express": "^4.18.2",
-    "winston": "^3.11.0",
-    "prom-client": "^15.1.0"
-  },
-  "devDependencies": {
-    "tsx": "^4.19.0",
-    "typescript": "^5.6.3",
-    "@types/node": "^20.11.0",
-    "@types/express": "^4.17.21",
-    "vitest": "^1.2.0",
-    "eslint": "^8.56.0",
-    "prettier": "^3.2.0"
-  }
-}
-```
-
-## Example 9: Environment Configuration
-
-```bash
-# .env.example
-
-# Required
-ANTHROPIC_API_KEY=sk-ant-...
-
-# Optional
-TOPIC="migrate payments service"
-DIFF="feat: add payments router and mandate checks"
-DATASET="monthly tx volume, refunds, chargebacks"
-
-# Logging
-LOG_LEVEL=info
-
-# Health Check
-HEALTH_PORT=3000
-
-# Metrics
-METRICS_PORT=9090
-
-# Retry Configuration
-MAX_RETRIES=3
-BACKOFF_MS=1000
-MAX_BACKOFF_MS=30000
-```
-
-## Example 10: Docker Compose with Monitoring
-
-```yaml
-# docker-compose.yml
-version: '3.8'
-
-services:
-  agent-orchestrator:
-    build: .
-    environment:
-      ANTHROPIC_API_KEY: ${ANTHROPIC_API_KEY}
-      LOG_LEVEL: ${LOG_LEVEL:-info}
-      HEALTH_PORT: 3000
-    ports:
-      - "3000:3000"
-    volumes:
-      - ./logs:/app/logs
-    restart: unless-stopped
-    healthcheck:
-      test: ["CMD", "curl", "-f", "http://localhost:3000/health"]
-      interval: 30s
-      timeout: 10s
-      retries: 3
-      start_period: 10s
-
-  prometheus:
-    image: prom/prometheus:latest
-    volumes:
-      - ./prometheus.yml:/etc/prometheus/prometheus.yml
-      - prometheus-data:/prometheus
-    ports:
-      - "9090:9090"
-    command:
-      - '--config.file=/etc/prometheus/prometheus.yml'
-      - '--storage.tsdb.path=/prometheus'
-    depends_on:
-      - agent-orchestrator
-
-  grafana:
-    image: grafana/grafana:latest
-    ports:
-      - "3001:3000"
-    volumes:
-      - grafana-data:/var/lib/grafana
-    environment:
-      GF_SECURITY_ADMIN_PASSWORD: ${GRAFANA_PASSWORD:-admin}
-      GF_INSTALL_PLUGINS: grafana-piechart-panel
-    depends_on:
-      - prometheus
-
-volumes:
-  prometheus-data:
-  grafana-data:
-```
-
-## Example 11: Prometheus Configuration
-
-```yaml
-# prometheus.yml
-global:
-  scrape_interval: 15s
-  evaluation_interval: 15s
-
-scrape_configs:
-  - job_name: 'claude-agents'
-    static_configs:
-      - targets: ['agent-orchestrator:3000']
-    metrics_path: '/metrics'
-```
-
-## Usage
-
-### Build and Run
-```bash
-# Install dependencies
-npm install
-
-# Development
-npm run dev
-
-# Production
-npm run build
-npm start
-
-# With Docker
-docker compose up --build
-
-# Health check
-curl http://localhost:3000/health
-
-# Metrics
-curl http://localhost:3000/metrics
-```
-
-### Environment Variables
-```bash
-export ANTHROPIC_API_KEY="sk-ant-..."
-export TOPIC="analyze security of authentication system"
-export LOG_LEVEL="debug"
-
-npm run dev
-```
-
-### Monitoring
-- **Health Check**: http://localhost:3000/health
-- **Metrics**: http://localhost:3000/metrics
-- **Prometheus**: http://localhost:9090
-- **Grafana**: http://localhost:3001 (admin/admin)
-
-### Logs
-```bash
-# View all logs
-tail -f logs/combined.log
-
-# View errors only
-tail -f logs/error.log
-
-# Search logs
-grep "agent_executions" logs/combined.log | jq
-```
-
-## Testing
-
-```bash
-# Run tests
-npm test
-
-# With coverage
-npm run test:coverage
-
-# Specific test
-npm test -- webResearchAgent
-```
-
-## Next Steps
-
-1. Implement these examples in your codebase
-2. Test each component individually
-3. Deploy to staging environment
-4. Monitor metrics and logs
-5. Iterate based on real usage patterns
-
-## Key Benefits
-
-- ✅ **10x reliability** with retry logic
-- ✅ **Real-time streaming** for better UX
-- ✅ **Full observability** with logs and metrics
-- ✅ **Production-ready** error handling
-- ✅ **Health monitoring** built-in
-- ✅ **Cost tracking** automatic
-- ✅ **Tool integration** enabled
-- ✅ **Scalable architecture** ready
-
-All code is production-ready and follows best practices from Anthropic's engineering team.