import { stream } from '@earendil-works/pi-ai/api/anthropic-messages';

const s = stream(claudeModel, context, {
  apiKey: process.env.ANTHROPIC_API_KEY,
  thinkingEnabled: true,
  thinkingBudgetTokens: 2048,
});

export function anthropicProvider() { ... }

// 消息上下文
interface Context {
  systemPrompt?: string;
  messages: Message[];
  tools?: Tool[];
}

// 消息（覆盖 user/assistant/toolResult 三种角色）
interface Message {
  role: 'user' | 'assistant' | 'toolResult';
  content: string | ContentBlock[];
  timestamp: number;
  // assistant 消息额外字段
  toolCallId?: string;
  toolName?: string;
  isError?: boolean;
}

// 内容块（统一四种表示）
type ContentBlock = TextContent | ThinkingContent | ToolCallContent | ImageContent;

// 工具定义（基于 TypeBox Schema）
interface Tool {
  name: string;
  description: string;
  parameters: TSchema;
}

import { createModels } from '@earendil-works/pi-ai';
import { anthropicProvider } from '@earendil-works/pi-ai/providers/anthropic';
import { openaiProvider } from '@earendil-works/pi-ai/providers/openai';
import { deepseekProvider } from '@earendil-works/pi-ai/providers/deepseek';

// 方式一：创建空集合，逐个注册供应商
const models = createModels();
models.setProvider(anthropicProvider());
models.setProvider(openaiProvider());
models.setProvider(deepseekProvider());

// 方式二：一次性注册所有内置供应商（适合不在意 bundle 大小的场景）
import { builtinModels } from '@earendil-works/pi-ai/providers/all';
const models = builtinModels(); // 包含 30+ 供应商的全部模型

// 获取所有供应商
const providers = models.getProviders();

// 获取指定供应商
const anthropic = models.getProvider('anthropic');

// 获取所有模型（跨供应商）
const allModels = models.getModels();
// 获取指定供应商的所有模型
const anthropicModels = models.getModels('anthropic');

// 获取指定供应商的指定模型
const model = models.getModel('anthropic', 'claude-sonnet-4-5');
// 如果找不到，返回 undefined（不是抛异常）

interface Model<Api extends string = string> {
  id: string;                  // 模型唯一 ID（如 'claude-sonnet-4-5'）
  name: string;                // 显示名称
  provider: string;            // 所属供应商 ID
  api: Api;                    // API 协议标识
  baseUrl?: string;            // API 端点基础 URL
  contextWindow: number;       // 最大上下文窗口（tokens）
  maxTokens: number;           // 最大输出 tokens
  reasoning: boolean;          // 是否支持推理/思考
  input: ('text' | 'image')[]; // 支持的输入类型
  cost: {                      // 定价（美元 / 百万 tokens）
    input: number;
    output: number;
    cacheRead: number;
    cacheWrite: number;
  };
}

import { hasApi } from '@earendil-works/pi-ai';

const m = models.getModel('anthropic', 'claude-sonnet-4-5');
if (m && hasApi(m, 'anthropic-messages')) {
  // m: Model<'anthropic-messages'> —— stream 选项完全类型化
  models.stream(m, context, { thinkingEnabled: true, thinkingBudgetTokens: 2048 });
}

import { getBuiltinModel, getBuiltinModels, getBuiltinProviders } from '@earendil-works/pi-ai/providers/all';

const model = getBuiltinModel('openai', 'gpt-5-mini'); // 已经是 Model<'openai-responses'>
const gptModels = getBuiltinModels('openai');

const model = models.getModel('openai', 'gpt-4o-mini')!;
const context: Context = {
  systemPrompt: '你是一个专业的编码助手。',
  messages: [
    { role: 'user', content: '用 TypeScript 写一个快速排序', timestamp: Date.now() }
  ]
};

const stream = models.stream(model, context);

for await (const event of stream) {
  switch (event.type) {
    case 'text_delta':
      process.stdout.write(event.delta);
      break;
    // ... 处理其他事件
  }
}

// 流结束后获取最终消息（包含完整的 content、usage、stopReason）
const finalMessage = await stream.result();

const s = models.stream(model, context);
// 消费事件...
const message = await s.result();

// message 包含：
// - content: ContentBlock[] — 完整的文本/推理/工具调用内容块
// - usage: { input: number; output: number; cacheRead?: number; cost: { input: number; output: number; total: number } }
// - stopReason: 'stop' | 'length' | 'toolUse' | 'error' | 'aborted'
// - errorMessage?: string — 仅在 stopReason 为 'error' 或 'aborted' 时存在

import { Type, type Context, type Tool } from '@earendil-works/pi-ai';
import { openaiProvider } from '@earendil-works/pi-ai/providers/openai';

const models = createModels();
models.setProvider(openaiProvider());

const getTimeTool: Tool = {
  name: 'get_time',
  description: '获取当前时间，可指定时区',
  parameters: Type.Object({
    timezone: Type.Optional(Type.String({ description: '时区，如 Asia/Shanghai' }))
  })
};

const context: Context = {
  systemPrompt: '你是一个助手。',
  messages: [{ role: 'user', content: '现在北京几点？', timestamp: Date.now() }],
  tools: [getTimeTool]
};

const model = models.getModel('openai', 'gpt-4o-mini')!;

// 循环直到模型不再请求工具
let hasToolCalls = true;
while (hasToolCalls) {
  hasToolCalls = false;
  const s = models.stream(model, context);

  for await (const event of s) {
    switch (event.type) {
      case 'text_delta':
        process.stdout.write(event.delta);
        break;
      case 'toolcall_end':
        console.log(`\n调用工具: ${event.toolCall.name}`);
        hasToolCalls = true;
        break;
    }
  }

  const message = await s.result();

  // 处理工具调用
  for (const block of message.content) {
    if (block.type === 'toolCall') {
      let result: string;
      if (block.name === 'get_time') {
        result = new Date().toLocaleString('zh-CN', {
          timeZone: block.arguments.timezone || 'Asia/Shanghai',
          dateStyle: 'full',
          timeStyle: 'long'
        });
      } else {
        result = '未知工具';
      }

      context.messages.push(message);
      context.messages.push({
        role: 'toolResult',
        toolCallId: block.id,
        toolName: block.name,
        content: [{ type: 'text', text: result }],
        isError: false,
        timestamp: Date.now()
      });
    }
  }
}

const response = await models.complete(model, context);

for (const block of response.content) {
  if (block.type === 'text') {
    console.log(block.text);
  } else if (block.type === 'toolCall') {
    console.log(`工具: ${block.name}(${JSON.stringify(block.arguments)})`);
  } else if (block.type === 'thinking') {
    console.log(`[推理]: ${block.thinking}`);
  }
}

console.log(`输入 tokens: ${response.usage.input}, 输出 tokens: ${response.usage.output}`);
console.log(`费用: $${response.usage.cost.total.toFixed(6)}`);

const response = await models.completeSimple(model, context, {
  reasoning: 'medium' // 'minimal' | 'low' | 'medium' | 'high' | 'xhigh'
});

import { builtinImagesModels } from '@earendil-works/pi-ai/providers/all';

const imagesModels = builtinImagesModels();
const model = imagesModels.getModel('openrouter', 'google/gemini-2.5-flash-image')!;

const result = await imagesModels.generateImages(model, {
  input: [{ type: 'text', text: '生成一个纯白背景上的红色圆形。' }]
});

for (const block of result.output) {
  if (block.type === 'text') {
    console.log(block.text);
  } else if (block.type === 'image') {
    console.log(`MIME: ${block.mimeType}`);
    console.log(`数据长度: ${block.data.length}`);
  }
}

console.log(model.input);  // ['text'] 或 ['text', 'image']
console.log(model.output); // ['image'] 或 ['image', 'text']

const auth = await models.getAuth(model);
if (auth) {
  console.log(`已配置，通过 ${auth.source}`); // 如 "ANTHROPIC_API_KEY", "OAuth", "stored credential"
} else {
  console.log('未配置');
}

interface CredentialStore {
  read(providerId: string): Promise<StoredCredential | undefined>;
  modify(providerId: string, fn: (current: StoredCredential | undefined) => StoredCredential | undefined): Promise<void>;
  delete(providerId: string): Promise<void>;
}

const models = createModels();
models.setProvider(anthropicProvider());
models.setProvider(openaiProvider());
models.setProvider(googleProvider());

const context: Context = { messages: [] };

// 先用 Claude（带扩展思考）
const claude = models.getModel('anthropic', 'claude-sonnet-4-5')!;
context.messages.push({ role: 'user', content: '25 × 18 等于多少？', timestamp: Date.now() });
context.messages.push(await models.completeSimple(claude, context, { reasoning: 'medium' }));

// 切换到 GPT-5 —— Claude 的思考痕迹自动转为 <thinking> 标记的文本
const gpt5 = models.getModel('openai', 'gpt-5-mini')!;
context.messages.push({ role: 'user', content: '这个计算正确吗？', timestamp: Date.now() });
context.messages.push(await models.complete(gpt5, context));

// 切换到 Gemini —— 同样自动转换
const gemini = models.getModel('google', 'gemini-2.5-flash')!;
context.messages.push({ role: 'user', content: '原始问题是什么？', timestamp: Date.now() });
const geminiResponse = await models.complete(gemini, context);

const s = models.stream(model, context);

for await (const event of s) {
  switch (event.type) {
    case 'toolcall_delta': {
      const toolCall = event.partial.content[event.contentIndex];
      if (toolCall.type === 'toolCall' && toolCall.arguments) {
        // toolCall.arguments 是部分解析的结果
        // 当流式进行时，可能包含不完整的值
        if (toolCall.arguments.path) {
          console.log(`正在操作文件: ${toolCall.arguments.path}`);
        }
        if (toolCall.arguments.content) {
          console.log(`内容预览: ${String(toolCall.arguments.content).substring(0, 100)}...`);
        }
      }
      break;
    }
    case 'toolcall_end': {
      // event.toolCall.arguments 现在是完整的，但还未通过 TypeBox 校验
      console.log(`工具调用完成: ${event.toolCall.name}`, event.toolCall.arguments);
      break;
    }
  }
}

import { validateToolCall, type Tool } from '@earendil-works/pi-ai';

for await (const event of s) {
  if (event.type === 'toolcall_end') {
    const toolCall = event.toolCall;
    try {
      const validatedArgs = validateToolCall(tools, toolCall);
      // validatedArgs 已经通过 TypeBox Schema 校验
      const result = await executeMyTool(toolCall.name, validatedArgs);
      // ...
    } catch (error) {
      // 校验失败——将错误作为工具结果返回，让模型重试
      context.messages.push({
        role: 'toolResult',
        toolCallId: toolCall.id,
        toolName: toolCall.name,
        content: [{ type: 'text', text: error.message }],
        isError: true,
        timestamp: Date.now()
      });
    }
  }
}

type ContentBlock = 
  | { type: 'text'; text: string }
  | { type: 'image'; data: string; mimeType: string }
  | { type: 'thinking'; thinking: string }
  | { type: 'toolCall'; id: string; name: string; arguments: Record<string, unknown> };

context.messages.push({
  role: 'toolResult',
  toolCallId: block.id,
  toolName: block.name,
  content: [
    { type: 'text', text: '图表已生成。' },
    { type: 'image', data: imageBuffer.toString('base64'), mimeType: 'image/png' }
  ],
  isError: false,
  timestamp: Date.now()
});

const controller = new AbortController();

// 2 秒后中止
setTimeout(() => controller.abort(), 2000);

const s = models.stream(model, context, {
  signal: controller.signal
});

for await (const event of s) {
  if (event.type === 'text_delta') {
    process.stdout.write(event.delta);
  } else if (event.type === 'error') {
    // event.reason 告诉你是因为 "error" 还是 "aborted"
    if (event.reason === 'aborted') {
      console.log('\n[请求已被用户中止]');
    }
  }
}

// 获取结果（如果被中止，message 包含部分内容）
const response = await s.result();
if (response.stopReason === 'aborted') {
  console.log('请求中止时的内容:', response.content);
  console.log('已消耗 tokens:', response.usage);
}

const controller1 = new AbortController();
setTimeout(() => controller1.abort(), 2000);

const partial = await models.complete(model, context, { signal: controller1.signal });

// partial.stopReason === 'aborted'
// partial.content 包含已生成的部分内容

context.messages.push(partial);
context.messages.push({ role: 'user', content: '请接着往下写', timestamp: Date.now() });

const continuation = await models.complete(model, context);
// 模型从被截断的地方继续生成

import { createModels, createProvider, envApiKeyAuth, type Model } from '@earendil-works/pi-ai';
import { openAICompletionsApi } from '@earendil-works/pi-ai/api/openai-completions.lazy';

const ollamaModel: Model<'openai-completions'> = {
  id: 'llama-3.1-8b',
  name: 'Llama 3.1 8B (Ollama)',
  api: 'openai-completions',
  provider: 'ollama',
  baseUrl: 'http://localhost:11434/v1',
  reasoning: false,
  input: ['text'],
  cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
  contextWindow: 128000,
  maxTokens: 32000,
};

const ollama = createProvider({
  id: 'ollama',
  name: 'Ollama',
  baseUrl: 'http://localhost:11434/v1',
  auth: { apiKey: { name: 'Ollama', resolve: async () => ({ auth: {} }) } },
  models: [ollamaModel],
  api: openAICompletionsApi(),
});

const models = createModels();
models.setProvider(ollama);

await models.complete(models.getModel('ollama', 'llama-3.1-8b')!, context);

const message = await models.complete(model, context);

console.log(`输入: ${message.usage.input} tokens`);
console.log(`输出: ${message.usage.output} tokens`);
if (message.usage.cacheRead) {
  console.log(`缓存命中: ${message.usage.cacheRead} tokens`);
}
console.log(`总计费用: $${message.usage.cost.total.toFixed(6)}`);
console.log(`  - 输入费用: $${message.usage.cost.input.toFixed(6)}`);
console.log(`  - 输出费用: $${message.usage.cost.output.toFixed(6)}`);

for await (const event of s) {
  if (event.type === 'error') {
    // event.reason: "error" | "aborted"
    // event.error.errorMessage: 错误描述
    // event.error.content: 错误前的部分内容
    console.error(`${event.reason}: ${event.error.errorMessage}`);
  }
}

const message = await s.result();
if (message.stopReason === 'error') {
  console.error('失败:', message.errorMessage);
  console.log('部分内容:', message.content);
}

const response = await models.complete(model, context, {
  onPayload: (payload) => {
    console.log('供应商请求负载:', JSON.stringify(payload, null, 2));
  }
});

import {
  fauxProvider,
  fauxAssistantMessage,
  fauxText,
  fauxThinking,
  fauxToolCall,
} from '@earendil-works/pi-ai';

const faux = fauxProvider({ tokensPerSecond: 50 });
models.setProvider(faux.provider);
const model = faux.getModel();

// 预置响应队列
faux.setResponses([
  fauxAssistantMessage([
    fauxThinking('需要先查看文件结构。'),
    fauxToolCall('read_file', { path: 'src/index.ts' }),
  ], { stopReason: 'toolUse' }),
]);

// 调用时按队列顺序消费
const response = await models.complete(model, context);
// response.content[0].type === 'thinking'
// response.content[1].type === 'toolCall'

// 查询状态
console.log(faux.state.callCount);       // 已调用次数
console.log(faux.getPendingResponseCount()); // 剩余待消费响应数