Vercel AI SDK — Full-Stack AI עם TypeScript

import { generateText } from 'ai';

// שימו לב: ב-v6, המודל הוא מחרוזת אחידה
// 'provider/model-name' — לא צריך לייבא provider
const { text } = await generateText({
  model: 'anthropic/claude-sonnet-4.5',
  prompt: 'Explain AI agents in 3 sentences.',
});

console.log(text);
// "AI agents are software systems that use LLMs
//  to reason about and execute multi-step tasks..."

import { streamText } from 'ai';

const result = streamText({
  model: 'openai/gpt-5',
  prompt: 'Write a business plan for an AI startup in Tel Aviv.',
});

// הדפסת tokens בזמן אמת
for await (const text of result.textStream) {
  process.stdout.write(text);
}

// אחרי שהסתיים — מידע שימושי
const finalResult = await result;
console.log('\n--- Usage ---');
console.log('Input tokens:', finalResult.usage.promptTokens);
console.log('Output tokens:', finalResult.usage.completionTokens);

import { generateText, Output } from 'ai';
import { z } from 'zod';

const { output } = await generateText({
  model: 'anthropic/claude-sonnet-4.5',
  output: Output.object({
    schema: z.object({
      company: z.string().describe('Company name'),
      founded: z.number().describe('Year founded'),
      industry: z.string(),
      strengths: z.array(z.string()),
      risk_level: z.enum(['low', 'medium', 'high']),
    }),
  }),
  prompt: 'Analyze Wix as a company.',
});

// output הוא typed! TypeScript יודע את המבנה
console.log(output.company);     // "Wix"
console.log(output.risk_level);  // "low"
console.log(output.strengths);   // ["Large user base", ...]

import { generateText, tool, stepCountIs } from 'ai';
import { z } from 'zod';

const result = await generateText({
  model: 'anthropic/claude-sonnet-4.5',
  tools: {
    weather: tool({
      description: 'Get current weather for a city. '
        + 'Use when the user asks about weather, temperature, '
        + 'or what to wear. Supports Hebrew and English city names.',
      inputSchema: z.object({
        city: z.string().describe('City name, e.g. "Tel Aviv" or "ירושלים"'),
        units: z.enum(['celsius', 'fahrenheit']).default('celsius'),
      }),
      execute: async ({ city, units }) => {
        // כאן קוראים ל-API אמיתי
        const response = await fetch(
          `https://api.weather.com/v1?city=${city}&units=${units}`
        );
        return response.json();
      },
    }),

    calculator: tool({
      description: 'Perform mathematical calculations. '
        + 'Use for any math the user asks about. '
        + 'Returns the numeric result.',
      inputSchema: z.object({
        expression: z.string().describe('Math expression, e.g. "15 * 23 + 7"'),
      }),
      execute: async ({ expression }) => {
        // בפרודקשן — השתמשו ב-math library, לא eval!
        return { result: Function(`return ${expression}`)() };
      },
    }),
  },
  // ב-v6: stopWhen מחליף את maxSteps
  stopWhen: stepCountIs(5),
  prompt: 'מה מזג האוויר בתל אביב? וכמה זה בפרנהייט?',
});

// result.text מכיל את התשובה הסופית
console.log(result.text);

// result.steps מכיל את כל הצעדים כולל tool calls
for (const step of result.steps) {
  console.log(`Step: ${step.toolCalls?.length ?? 0} tool calls`);
}

import { ToolLoopAgent, tool, Output } from 'ai';
import { z } from 'zod';

// הגדרת הסוכן — פעם אחת
const researchAgent = new ToolLoopAgent({
  model: 'anthropic/claude-sonnet-4.5',
  instructions: `You are a research assistant specializing in the
    Israeli tech ecosystem. You search for information, analyze data,
    and provide structured summaries. Always cite your sources.
    You speak Hebrew and English fluently.`,

  tools: {
    webSearch: tool({
      description: 'Search the web for current information. '
        + 'Returns top 5 results with title, snippet, and URL.',
      inputSchema: z.object({
        query: z.string().describe('Search query in English or Hebrew'),
      }),
      execute: async ({ query }) => {
        // חיבור ל-Brave Search API או SerpAPI
        return { results: [/* ... */] };
      },
    }),

    summarize: tool({
      description: 'Summarize a long text into key points. '
        + 'Use after webSearch to distill search results.',
      inputSchema: z.object({
        text: z.string(),
        max_points: z.number().default(5),
      }),
      execute: async ({ text, max_points }) => {
        // summarization logic
        return { points: [/* ... */] };
      },
    }),
  },

  // structured output — הסוכן מחזיר אובייקט מובנה
  output: Output.object({
    schema: z.object({
      topic: z.string(),
      summary: z.string(),
      key_findings: z.array(z.string()),
      sources: z.array(z.object({
        title: z.string(),
        url: z.string(),
      })),
      confidence: z.enum(['high', 'medium', 'low']),
    }),
  }),
});

// שימוש 1: generate (ממתין לתשובה מלאה)
const { output } = await researchAgent.generate({
  prompt: 'Research the current state of AI startups in Israel.',
});
console.log(output.key_findings);
console.log(output.confidence);

// שימוש 2: stream (streaming לזמן אמת)
const { partialOutputStream } = await researchAgent.stream({
  prompt: 'What are the top funded AI companies in Tel Aviv?',
});
for await (const partial of partialOutputStream) {
  console.log(partial); // אובייקט חלקי שגדל לאט
}

import { ToolLoopAgent, tool, createAgentUIStreamResponse } from 'ai';
import { z } from 'zod';

// הגדרת הסוכן
const chatAgent = new ToolLoopAgent({
  model: 'anthropic/claude-sonnet-4.5',
  instructions: `You are a helpful assistant for Israeli businesses.
    You can search the web, calculate numbers, and analyze data.
    Respond in the language the user writes in (Hebrew or English).`,
  tools: {
    weather: tool({
      description: 'Get weather for a city',
      inputSchema: z.object({
        city: z.string(),
      }),
      execute: async ({ city }) => {
        return { temp: 28, condition: 'sunny', city };
      },
    }),
  },
});

export async function POST(req: Request) {
  const { messages } = await req.json();

  // createAgentUIStreamResponse — מחבר agent ל-useChat
  return createAgentUIStreamResponse({
    agent: chatAgent,
    messages,
  });
}

'use client';

import { useChat } from '@ai-sdk/react';
import { useState } from 'react';

export default function ChatPage() {
  const [input, setInput] = useState('');
  const { messages, sendMessage, status } = useChat();
  const isActive = status === 'streaming' || status === 'submitted';

  return (
    <div style={{ maxWidth: '600px', margin: '0 auto', padding: '20px' }}>
      <h1>AI Agent Chat</h1>

      {/* הצגת הודעות */}
      <div>
        {messages.map((m) => (
          <div key={m.id} style={{
            padding: '10px',
            margin: '5px 0',
            background: m.role === 'user' ? '#e3f2fd' : '#f5f5f5',
            borderRadius: '8px',
          }}>
            <strong>{m.role === 'user' ? 'You' : 'Agent'}:</strong>
            {m.parts?.map((part, i) => {
              switch (part.type) {
                case 'text':
                  return <p key={i}>{part.text}</p>;
                default:
                  // ב-v6, tool parts הם tool-<toolName>
                  // למשל: 'tool-weather', 'tool-calculator'
                  if (part.type.startsWith('tool-')) {
                    return (
                      <div key={i} style={{
                        background: '#fff3e0',
                        padding: '5px',
                        borderRadius: '4px',
                        fontSize: '0.85em',
                      }}>
                        Tool: {part.type.replace('tool-', '')}
                        {'result' in part && (
                          <span> = {JSON.stringify(part.result)}</span>
                        )}
                      </div>
                    );
                  }
                  return null;
              }
            })}
          </div>
        ))}
        {isActive && <p>...thinking</p>}
      </div>

      {/* טופס שליחה */}
      <form onSubmit={(e) => {
        e.preventDefault();
        if (input.trim()) {
          sendMessage({ text: input });
          setInput('');
        }
      }}>
        <input
          value={input}
          onChange={(e) => setInput(e.target.value)}
          placeholder="שאל את הסוכן..."
          style={{ width: '80%', padding: '10px' }}
          disabled={isActive}
        />
        <button type="submit" disabled={isActive}>שלח</button>
      </form>
    </div>
  );
}

import { generateText, tool } from 'ai';
import { z } from 'zod';

// הכלים זהים — לא משנים כלום
const tools = {
  search: tool({
    description: 'Search the web',
    inputSchema: z.object({ query: z.string() }),
    execute: async ({ query }) => ({ results: [`Result for: ${query}`] }),
  }),
};

// שורה אחת — מחליפים provider + model
// Anthropic
const r1 = await generateText({
  model: 'anthropic/claude-sonnet-4.5',
  tools,
  stopWhen: stepCountIs(5),
  prompt: 'Search for AI startups in Israel',
});

// OpenAI — אותו קוד, אותם tools
const r2 = await generateText({
  model: 'openai/gpt-5',
  tools,
  stopWhen: stepCountIs(5),
  prompt: 'Search for AI startups in Israel',
});

// Google — אותו קוד, אותם tools
const r3 = await generateText({
  model: 'google/gemini-2.5-pro',
  tools,
  stopWhen: stepCountIs(5),
  prompt: 'Search for AI startups in Israel',
});

import { generateText } from 'ai';

type Complexity = 'simple' | 'moderate' | 'complex';

// ניתוח מורכבות בסיסי
function classifyComplexity(prompt: string): Complexity {
  const wordCount = prompt.split(' ').length;
  if (wordCount < 20) return 'simple';
  if (wordCount < 100) return 'moderate';
  return 'complex';
}

// טבלת routing — מודל לכל רמת מורכבות
const MODEL_ROUTER: Record<Complexity, string> = {
  simple:   'google/gemini-2.5-flash',     // $0.30/M input — זול ומהיר
  moderate: 'anthropic/claude-sonnet-4.5',  // $3/M input — איזון טוב
  complex:  'anthropic/claude-opus-4.6',    // $5/M input — מקסימום יכולת
};

async function smartGenerate(prompt: string) {
  const complexity = classifyComplexity(prompt);
  const model = MODEL_ROUTER[complexity];

  console.log(`[Router] ${complexity} -> ${model}`);

  return generateText({
    model,
    prompt,
  });
}

// שימוש
await smartGenerate('Hi');
// [Router] simple -> google/gemini-2.5-flash

await smartGenerate('Analyze the competitive landscape...');
// [Router] complex -> anthropic/claude-opus-4.6

async function generateWithFallback(prompt: string): Promise<string> {
  const models = [
    'anthropic/claude-sonnet-4.5',  // ראשון — מועדף
    'openai/gpt-5',                 // שני — גיבוי
    'google/gemini-2.5-pro',        // שלישי — גיבוי אחרון
  ];

  for (const model of models) {
    try {
      const { text } = await generateText({ model, prompt });
      return text;
    } catch (error) {
      console.warn(`[Fallback] ${model} failed, trying next...`);
      continue;
    }
  }

  throw new Error('All providers failed');
}

import { generateText, Output } from 'ai';
import { z } from 'zod';

// חילוץ מידע ממייל
const { output } = await generateText({
  model: 'anthropic/claude-sonnet-4.5',
  output: Output.object({
    schema: z.object({
      sender: z.string(),
      subject: z.string(),
      urgency: z.enum(['low', 'medium', 'high', 'critical']),
      action_required: z.boolean(),
      action_items: z.array(z.string()),
      due_date: z.string().nullable(),
      sentiment: z.enum(['positive', 'neutral', 'negative']),
    }),
  }),
  prompt: `Extract structured data from this email:
    "Hi Team, urgent - the client demo is tomorrow at 2pm.
    We need to fix the login bug and prepare the slide deck
    before end of day. Thanks, Yossi"`,
});

// output typed!
console.log(output.urgency);        // "high"
console.log(output.action_required); // true
console.log(output.action_items);
// ["Fix the login bug", "Prepare the slide deck"]
console.log(output.due_date);       // "end of day"

import { ToolLoopAgent, Output, tool } from 'ai';
import { z } from 'zod';

const weatherReporter = new ToolLoopAgent({
  model: 'anthropic/claude-sonnet-4.5',
  tools: {
    weather: tool({
      description: 'Get weather for a city',
      inputSchema: z.object({ city: z.string() }),
      execute: async ({ city }) => ({
        temp_c: 28,
        condition: 'sunny',
        humidity: 65,
        city,
      }),
    }),
  },
  output: Output.object({
    schema: z.object({
      summary: z.string(),
      temperature: z.number(),
      recommendation: z.string(),
      should_bring_umbrella: z.boolean(),
    }),
  }),
});

const { output } = await weatherReporter.generate({
  prompt: 'What is the weather in Tel Aviv? Should I bring an umbrella?',
});

// הסוכן קרא ל-weather tool, קיבל תוצאה,
// ואז מילא את ה-structured output
console.log(output.temperature);           // 28
console.log(output.should_bring_umbrella); // false
console.log(output.recommendation);
// "No umbrella needed - it's sunny and warm in Tel Aviv!"

import { generateText, stepCountIs } from 'ai';
import { createMCPClient } from 'ai/mcp';

// יצירת MCP client שמתחבר לשרת
const mcpClient = await createMCPClient({
  transport: {
    type: 'sse',
    url: 'http://localhost:3001/mcp',  // MCP Server ששומע ב-HTTP
  },
});

// טעינת כלים מה-MCP Server
const mcpTools = await mcpClient.tools();

// שימוש בכלים מ-MCP יחד עם כלים native
const result = await generateText({
  model: 'anthropic/claude-sonnet-4.5',
  tools: {
    ...mcpTools,           // כלים מ-MCP Server
    myNativeTool: tool({   // כלי native נוסף
      description: 'My custom tool',
      inputSchema: z.object({ input: z.string() }),
      execute: async ({ input }) => ({ result: input.toUpperCase() }),
    }),
  },
  stopWhen: stepCountIs(5),
  prompt: 'Use the available tools to help me.',
});

// סגירת ה-MCP connection כשסיימנו
await mcpClient.close();

import { createMCPClient } from 'ai/mcp';

const mcpClient = await createMCPClient({
  transport: {
    type: 'stdio',
    command: 'node',
    args: ['./my-mcp-server.js'],
  },
});

const tools = await mcpClient.tools();
// עכשיו אפשר להשתמש ב-tools ב-generateText/ToolLoopAgent

import { ToolLoopAgent, tool, Output, stepCountIs } from 'ai';
import { createMCPClient } from 'ai/mcp';
import { z } from 'zod';

// חיבור ל-MCP Server (למשל: GitHub MCP Server)
const githubMCP = await createMCPClient({
  transport: {
    type: 'stdio',
    command: 'npx',
    args: ['-y', '@modelcontextprotocol/server-github'],
    env: { GITHUB_TOKEN: process.env.GITHUB_TOKEN! },
  },
});

// טעינת כלים מ-MCP — סינון רק מה שצריך!
const allMCPTools = await githubMCP.tools();
const relevantTools = Object.fromEntries(
  Object.entries(allMCPTools).filter(([name]) =>
    ['create_issue', 'list_issues', 'search_code'].includes(name)
  )
);

// הגדרת סוכן משולב
const devAgent = new ToolLoopAgent({
  model: 'anthropic/claude-sonnet-4.5',
  instructions: `You are a developer assistant.
You can search GitHub repos, create issues, and analyze code.
Always explain what you're doing before using a tool.
Respond in the user's language.`,

  tools: {
    // כלים מ-MCP
    ...relevantTools,

    // כלי native — code analysis
    analyzeCode: tool({
      description: 'Analyze a code snippet for bugs, performance, '
        + 'and best practices. Returns structured feedback.',
      inputSchema: z.object({
        code: z.string().describe('Code snippet to analyze'),
        language: z.enum(['python', 'typescript', 'javascript']),
      }),
      execute: async ({ code, language }) => {
        // לוגיקת ניתוח (במציאות — LLM call נוסף או static analysis)
        return {
          issues_found: 2,
          severity: 'medium',
          suggestions: [
            'Add error handling for API calls',
            'Consider using async/await instead of callbacks'
          ],
        };
      },
    }),
  },

  output: Output.object({
    schema: z.object({
      summary: z.string(),
      actions_taken: z.array(z.string()),
      github_links: z.array(z.string()).optional(),
    }),
  }),
});

// שימוש
const { output } = await devAgent.generate({
  prompt: 'Find open issues in my repo labeled "bug" and create '
    + 'a summary issue linking them all together.',
});

console.log(output.summary);
console.log(output.actions_taken);

// ניקוי — חשוב! סוגרים MCP connections
await githubMCP.close();

import { createMCPClient } from 'ai/mcp';

async function createRobustMCPClient(config: {
  transport: any;
  retries?: number;
  timeoutMs?: number;
}) {
  const { transport, retries = 3, timeoutMs = 10000 } = config;

  for (let attempt = 1; attempt <= retries; attempt++) {
    try {
      const client = await Promise.race([
        createMCPClient({ transport }),
        new Promise((_, reject) =>
          setTimeout(
            () => reject(new Error('MCP connection timeout')),
            timeoutMs
          )
        ),
      ]);
      console.log(`MCP connected (attempt ${attempt})`);
      return client;
    } catch (error) {
      console.warn(
        `MCP connection attempt ${attempt}/${retries} failed:`,
        (error as Error).message
      );
      if (attempt === retries) {
        console.error('All MCP connection attempts failed');
        return null; // Graceful degradation — agent works without MCP
      }
      // Wait before retry
      await new Promise(r =>
        setTimeout(r, 1000 * Math.pow(2, attempt - 1))
      );
    }
  }
  return null;
}

// שימוש — הסוכן עובד גם אם MCP לא זמין
const mcpClient = await createRobustMCPClient({
  transport: { type: 'sse', url: 'http://localhost:3001/mcp' },
  retries: 3,
  timeoutMs: 5000,
});

const mcpTools = mcpClient
  ? await mcpClient.tools()
  : {}; // Fallback — אין MCP tools

const agent = new ToolLoopAgent({
  model: 'anthropic/claude-sonnet-4.5',
  tools: {
    ...mcpTools, // ריק אם MCP לא זמין
    // native tools עובדים תמיד
    myTool: tool({ /* ... */ }),
  },
});

import { ToolLoopAgent, tool } from 'ai';
import { z } from 'zod';

const agent = new ToolLoopAgent({
  model: 'anthropic/claude-sonnet-4.5',
  tools: {
    // כלי בטוח — לא צריך אישור
    search: tool({
      description: 'Search the web (safe, read-only)',
      inputSchema: z.object({ query: z.string() }),
      execute: async ({ query }) => ({ results: [/* ... */] }),
    }),

    // כלי מסוכן — דורש אישור!
    sendEmail: tool({
      description: 'Send an email. REQUIRES USER APPROVAL.',
      inputSchema: z.object({
        to: z.string(),
        subject: z.string(),
        body: z.string(),
      }),
      // needsApproval: הסוכן עוצר ומבקש אישור
      needsApproval: true,
      execute: async ({ to, subject, body }) => {
        // נקרא רק אחרי שהמשתמש אישר
        await sendEmailAPI(to, subject, body);
        return { sent: true };
      },
    }),

    // אפשר גם needsApproval דינאמי — פונקציה שמחליטה
    deleteFile: tool({
      description: 'Delete a file from the system',
      inputSchema: z.object({ path: z.string() }),
      needsApproval: ({ path }) => {
        // קבצים ב-/tmp לא צריכים אישור, השאר כן
        return !path.startsWith('/tmp/');
      },
      execute: async ({ path }) => {
        // delete logic
        return { deleted: true };
      },
    }),
  },
});

import { generateText } from 'ai';

const result = await generateText({
  model: 'anthropic/claude-sonnet-4.5',
  prompt: 'Hello!',
  // הפעלת telemetry
  experimental_telemetry: {
    isEnabled: true,
    functionId: 'chat-agent',
    metadata: {
      userId: 'user-123',
      sessionId: 'session-456',
    },
  },
});

// Token usage מדויק
console.log('Input tokens:', result.usage.promptTokens);
console.log('Output tokens:', result.usage.completionTokens);

// חישוב עלות
const inputCost = result.usage.promptTokens * 3 / 1_000_000;   // $3/M for Sonnet
const outputCost = result.usage.completionTokens * 15 / 1_000_000;
console.log(`Cost: $${(inputCost + outputCost).toFixed(4)}`);

// Cost tracker שנשמר בזיכרון (בפרודקשן — Redis/DB)
const dailyCosts = new Map<string, number>();

function trackCost(userId: string, usage: {
  promptTokens: number;
  completionTokens: number;
}, model: string) {
  // חישוב עלות
  const prices: Record<string, [number, number]> = {
    'anthropic/claude-sonnet-4.5': [3, 15],
    'google/gemini-2.5-flash': [0.15, 0.60],
  };
  const [inPrice, outPrice] = prices[model] ?? [5, 15];
  const cost = (
    usage.promptTokens * inPrice +
    usage.completionTokens * outPrice
  ) / 1_000_000;

  // עדכון סכום יומי
  const today = new Date().toISOString().slice(0, 10);
  const key = `${today}:${userId}`;
  const current = dailyCosts.get(key) ?? 0;
  dailyCosts.set(key, current + cost);

  // התראות
  const dailyTotal = dailyCosts.get(key)!;
  if (dailyTotal > 5) {
    console.error(
      `[COST ALERT] User ${userId} exceeded $5/day: $${dailyTotal.toFixed(2)}`
    );
    // בפרודקשן: שליחת Slack notification / email
  }

  return { cost, dailyTotal };
}

// app/api/chat/route.ts
import { ToolLoopAgent, tool, createAgentUIStreamResponse } from 'ai';
import { z } from 'zod';

// maxDuration מגדיל את ה-timeout של ה-Serverless Function
export const maxDuration = 60; // שניות

const agent = new ToolLoopAgent({
  model: 'anthropic/claude-sonnet-4.5',
  instructions: 'You are a helpful assistant.',
  tools: { /* ... */ },
});

export async function POST(req: Request) {
  const { messages } = await req.json();
  return createAgentUIStreamResponse({ agent, messages });
}

// Cloudflare Worker — AI SDK עם streaming
export default {
  async fetch(request: Request, env: Env): Promise<Response> {
    if (request.method !== 'POST') {
      return new Response('Method not allowed', { status: 405 });
    }

    const { messages } = await request.json();

    // AI SDK עובד ב-Cloudflare Workers!
    const result = streamText({
      model: 'anthropic/claude-sonnet-4.5',
      messages,
      // ב-Workers, API key מגיע מ-environment
      // שהוגדר ב-wrangler.toml
    });

    // מחזירים Response עם streaming (v6: toUIMessageStreamResponse לצ'אט, toTextStreamResponse לטקסט)
    return result.toUIMessageStreamResponse();
  },
} satisfies ExportedHandler<Env>;

# Dockerfile לסוכן AI SDK
FROM node:20-alpine

WORKDIR /app

# Dependencies
COPY package*.json ./
RUN npm ci --production

# קוד
COPY . .
RUN npm run build

# Environment variables — מוזרקים ב-runtime, לא ב-build!
# API keys צריכים להיות ב-docker run -e או docker-compose
ENV PORT=3000

EXPOSE 3000
CMD ["node", "dist/server.js"]

# הרצה:
# docker build -t ai-agent .
# docker run -p 3000:3000 \
#   -e ANTHROPIC_API_KEY=sk-ant-... \
#   -e OPENAI_API_KEY=sk-... \
#   ai-agent

// Simple in-memory rate limiter
const rateLimitMap = new Map<string, { count: number; resetTime: number }>();

function checkRateLimit(
  userId: string,
  maxRequests = 20,
  windowMs = 60_000  // 1 דקה
): { allowed: boolean; remaining: number } {
  const now = Date.now();
  const entry = rateLimitMap.get(userId);

  if (!entry || now > entry.resetTime) {
    rateLimitMap.set(userId, { count: 1, resetTime: now + windowMs });
    return { allowed: true, remaining: maxRequests - 1 };
  }

  if (entry.count >= maxRequests) {
    return { allowed: false, remaining: 0 };
  }

  entry.count++;
  return { allowed: true, remaining: maxRequests - entry.count };
}

// שימוש ב-API Route
export async function POST(req: Request) {
  const userId = req.headers.get('x-user-id') ?? 'anonymous';
  const { allowed, remaining } = checkRateLimit(userId);

  if (!allowed) {
    return new Response(
      JSON.stringify({ error: 'Rate limit exceeded. Try again in 1 minute.' }),
      {
        status: 429,
        headers: {
          'X-RateLimit-Remaining': '0',
          'Retry-After': '60',
        },
      }
    );
  }

  // ... המשך לסוכן
}

import { generateText } from 'ai';

type ProviderError = {
  provider: string;
  error: string;
  retryable: boolean;
};

async function generateWithSmartFallback(
  prompt: string,
  tools?: Record<string, any>
): Promise<{ text: string; provider: string; errors: ProviderError[] }> {
  const providers = [
    { model: 'anthropic/claude-sonnet-4.5', name: 'Anthropic' },
    { model: 'openai/gpt-4o', name: 'OpenAI' },
    { model: 'google/gemini-2.5-pro', name: 'Google' },
  ];

  const errors: ProviderError[] = [];

  for (const { model, name } of providers) {
    try {
      const result = await generateText({
        model,
        prompt,
        tools,
        // Timeout per provider
        abortSignal: AbortSignal.timeout(30_000),
      });
      return { text: result.text, provider: name, errors };
    } catch (error) {
      const err = error as Error;
      const isRetryable =
        err.message.includes('429') ||
        err.message.includes('503') ||
        err.message.includes('timeout');

      errors.push({
        provider: name,
        error: err.message,
        retryable: isRetryable,
      });

      console.warn(`[Fallback] ${name} failed: ${err.message}`);
    }
  }

  throw new Error(
    `All providers failed: ${errors.map(e => e.provider).join(', ')}`
  );
}

import { tool } from 'ai';
import { z } from 'zod';

// Helper: עוטף כל execute function בהגנה
function safeTool<T extends z.ZodTypeAny>(config: {
  description: string;
  inputSchema: T;
  execute: (args: z.infer<T>) => Promise<any>;
  timeoutMs?: number;
  fallback?: any;
}) {
  const {
    description, inputSchema, execute,
    timeoutMs = 10000, fallback = { error: 'Tool unavailable' }
  } = config;

  return tool({
    description,
    inputSchema,
    execute: async (args) => {
      try {
        const result = await Promise.race([
          execute(args),
          new Promise((_, reject) =>
            setTimeout(
              () => reject(new Error('Tool timeout')),
              timeoutMs
            )
          ),
        ]);
        return result;
      } catch (error) {
        console.error(
          `Tool error: ${description.slice(0, 50)}`,
          (error as Error).message
        );
        return fallback;
      }
    },
  });
}

// שימוש — כל כלי מוגן אוטומטית
const weatherTool = safeTool({
  description: 'Get weather for a city',
  inputSchema: z.object({ city: z.string() }),
  execute: async ({ city }) => {
    const res = await fetch(`https://api.weather.com/v1?q=${city}`);
    if (!res.ok) throw new Error(`API error: ${res.status}`);
    return res.json();
  },
  timeoutMs: 5000,
  fallback: { error: 'Weather service unavailable', city },
});

// מעקב עלות per-session עם התראה
class CostGuard {
  private totalCost = 0;
  private readonly maxCost: number;
  private readonly onBudgetAlert: (cost: number) => void;

  constructor(
    maxCostPerSession: number,
    onAlert: (cost: number) => void
  ) {
    this.maxCost = maxCostPerSession;
    this.onBudgetAlert = onAlert;
  }

  trackUsage(usage: {
    promptTokens: number;
    completionTokens: number;
  }, model: string) {
    // מחירים משוערים per 1M tokens
    const prices: Record<string, [number, number]> = {
      'anthropic/claude-sonnet-4.5': [3, 15],
      'openai/gpt-4o': [2.5, 10],
      'google/gemini-2.5-pro': [1.25, 5],
      'google/gemini-2.5-flash': [0.15, 0.60],
    };
    const [inputPrice, outputPrice] = prices[model] ?? [5, 15];

    const cost =
      (usage.promptTokens * inputPrice +
        usage.completionTokens * outputPrice) /
      1_000_000;

    this.totalCost += cost;

    if (this.totalCost > this.maxCost * 0.8) {
      this.onBudgetAlert(this.totalCost);
    }

    return {
      stepCost: cost,
      totalCost: this.totalCost,
      budgetRemaining: this.maxCost - this.totalCost,
      overBudget: this.totalCost > this.maxCost,
    };
  }
}

// שימוש
const guard = new CostGuard(1.0, (cost) => {
  console.warn(`Budget alert! $${cost.toFixed(4)} spent`);
});