@zhin.js/core 1.0.25 → 1.0.27

package/src/ai/output.ts

@@ -0,0 +1,261 @@
+/**
+ * @zhin.js/ai - Multi-modal Output Pipeline
+ *
+ * 统一输出类型系统：AI 回复 → OutputElement[] → Adapter 渲染
+ *
+ * 支持的输出类型:
+ *   - text:  纯文本 / markdown
+ *   - image: 图片 URL 或 base64
+ *   - audio: 音频 URL 或 base64
+ *   - video: 视频 URL
+ *   - card:  结构化卡片 (标题 + 正文 + 字段 + 按钮)
+ *   - file:  文件附件
+ */
+
+// ============================================================================
+// OutputElement 类型定义
+// ============================================================================
+
+export interface TextElement {
+  type: 'text';
+  content: string;
+  /** markdown / plain */
+  format?: 'markdown' | 'plain';
+}
+
+export interface ImageElement {
+  type: 'image';
+  url: string;
+  /** base64 数据 (url 不可用时的后备) */
+  base64?: string;
+  alt?: string;
+  width?: number;
+  height?: number;
+}
+
+export interface AudioElement {
+  type: 'audio';
+  url: string;
+  base64?: string;
+  duration?: number;
+  /** 语音转文字的后备文本 */
+  fallbackText?: string;
+}
+
+export interface VideoElement {
+  type: 'video';
+  url: string;
+  coverUrl?: string;
+  duration?: number;
+  fallbackText?: string;
+}
+
+export interface CardField {
+  label: string;
+  value: string;
+  inline?: boolean;
+}
+
+export interface CardButton {
+  text: string;
+  /** 点击后发送的命令 */
+  command?: string;
+  /** 点击后打开的 URL */
+  url?: string;
+}
+
+export interface CardElement {
+  type: 'card';
+  title: string;
+  description?: string;
+  fields?: CardField[];
+  imageUrl?: string;
+  buttons?: CardButton[];
+  color?: string;
+}
+
+export interface FileElement {
+  type: 'file';
+  url: string;
+  name: string;
+  size?: number;
+  mimeType?: string;
+}
+
+export type OutputElement =
+  | TextElement
+  | ImageElement
+  | AudioElement
+  | VideoElement
+  | CardElement
+  | FileElement;
+
+// ============================================================================
+// 输出解析器 — 将 AI 原始回复转换为 OutputElement[]
+// ============================================================================
+
+/**
+ * 从 AI 回复文本中解析出结构化的 OutputElement[]
+ *
+ * 识别规则:
+ *   - ![alt](url)            → ImageElement
+ *   - [audio](url)           → AudioElement
+ *   - [video](url)           → VideoElement
+ *   - ```card ... ```        → CardElement (JSON)
+ *   - [file:name](url)       → FileElement
+ *   - 其余文本               → TextElement
+ */
+export function parseOutput(raw: string): OutputElement[] {
+  if (!raw || !raw.trim()) return [{ type: 'text', content: '', format: 'plain' }];
+
+  const elements: OutputElement[] = [];
+  let remaining = raw;
+
+  // eslint-disable-next-line no-constant-condition
+  while (remaining.length > 0) {
+    // ── 尝试匹配 card 代码块 ──
+    const cardMatch = remaining.match(/^([\s\S]*?)```card\s*\n([\s\S]*?)```/);
+    if (cardMatch) {
+      // 前缀文本
+      if (cardMatch[1].trim()) {
+        elements.push({ type: 'text', content: cardMatch[1].trim(), format: 'markdown' });
+      }
+      // 解析卡片 JSON
+      try {
+        const cardData = JSON.parse(cardMatch[2]);
+        elements.push({ ...cardData, type: 'card' });
+      } catch {
+        elements.push({ type: 'text', content: cardMatch[2], format: 'plain' });
+      }
+      remaining = remaining.slice(cardMatch[0].length);
+      continue;
+    }
+
+    // ── 尝试匹配 image: ![alt](url) ──
+    const imgMatch = remaining.match(/^([\s\S]*?)!\[([^\]]*)\]\(([^)]+)\)/);
+    if (imgMatch && imgMatch[1].length < 500) {
+      if (imgMatch[1].trim()) {
+        elements.push({ type: 'text', content: imgMatch[1].trim(), format: 'markdown' });
+      }
+      elements.push({ type: 'image', url: imgMatch[3], alt: imgMatch[2] || undefined });
+      remaining = remaining.slice(imgMatch[0].length);
+      continue;
+    }
+
+    // ── 尝试匹配 audio: [audio](url) ──
+    const audioMatch = remaining.match(/^([\s\S]*?)\[audio\]\(([^)]+)\)/i);
+    if (audioMatch && audioMatch[1].length < 500) {
+      if (audioMatch[1].trim()) {
+        elements.push({ type: 'text', content: audioMatch[1].trim(), format: 'markdown' });
+      }
+      elements.push({ type: 'audio', url: audioMatch[2] });
+      remaining = remaining.slice(audioMatch[0].length);
+      continue;
+    }
+
+    // ── 尝试匹配 video: [video](url) ──
+    const videoMatch = remaining.match(/^([\s\S]*?)\[video\]\(([^)]+)\)/i);
+    if (videoMatch && videoMatch[1].length < 500) {
+      if (videoMatch[1].trim()) {
+        elements.push({ type: 'text', content: videoMatch[1].trim(), format: 'markdown' });
+      }
+      elements.push({ type: 'video', url: videoMatch[2] });
+      remaining = remaining.slice(videoMatch[0].length);
+      continue;
+    }
+
+    // ── 尝试匹配 file: [file:name](url) ──
+    const fileMatch = remaining.match(/^([\s\S]*?)\[file:([^\]]+)\]\(([^)]+)\)/i);
+    if (fileMatch && fileMatch[1].length < 500) {
+      if (fileMatch[1].trim()) {
+        elements.push({ type: 'text', content: fileMatch[1].trim(), format: 'markdown' });
+      }
+      elements.push({ type: 'file', url: fileMatch[3], name: fileMatch[2] });
+      remaining = remaining.slice(fileMatch[0].length);
+      continue;
+    }
+
+    // ── 无匹配 → 全部作为文本 ──
+    elements.push({ type: 'text', content: remaining.trim(), format: 'markdown' });
+    break;
+  }
+
+  return elements.length > 0 ? elements : [{ type: 'text', content: raw, format: 'plain' }];
+}
+
+// ============================================================================
+// OutputElement 渲染工具
+// ============================================================================
+
+/**
+ * 将 OutputElement[] 降级为纯文本（用于不支持富媒体的平台）
+ */
+export function renderToPlainText(elements: OutputElement[]): string {
+  return elements.map(el => {
+    switch (el.type) {
+      case 'text':
+        return el.content;
+      case 'image':
+        return el.alt ? `[图片: ${el.alt}]` : `[图片: ${el.url}]`;
+      case 'audio':
+        return el.fallbackText || `[音频: ${el.url}]`;
+      case 'video':
+        return el.fallbackText || `[视频: ${el.url}]`;
+      case 'card': {
+        const parts = [el.title];
+        if (el.description) parts.push(el.description);
+        if (el.fields?.length) {
+          for (const f of el.fields) parts.push(`${f.label}: ${f.value}`);
+        }
+        return parts.join('\n');
+      }
+      case 'file':
+        return `[文件: ${el.name}] ${el.url}`;
+      default:
+        return '';
+    }
+  }).filter(Boolean).join('\n');
+}
+
+/**
+ * 将 OutputElement[] 渲染为 Satori 兼容的 HTML 片段
+ */
+export function renderToSatori(elements: OutputElement[]): string {
+  return elements.map(el => {
+    switch (el.type) {
+      case 'text':
+        return `<p>${escapeHtml(el.content)}</p>`;
+      case 'image':
+        return `<img src="${escapeHtml(el.url)}"${el.alt ? ` alt="${escapeHtml(el.alt)}"` : ''}/>`;
+      case 'audio':
+        return el.fallbackText
+          ? `<p>${escapeHtml(el.fallbackText)}</p>`
+          : `<audio src="${escapeHtml(el.url)}"/>`;
+      case 'video':
+        return el.fallbackText
+          ? `<p>${escapeHtml(el.fallbackText)}</p>`
+          : `<video src="${escapeHtml(el.url)}"/>`;
+      case 'card': {
+        let html = `<div class="card">`;
+        html += `<h3>${escapeHtml(el.title)}</h3>`;
+        if (el.description) html += `<p>${escapeHtml(el.description)}</p>`;
+        if (el.imageUrl) html += `<img src="${escapeHtml(el.imageUrl)}"/>`;
+        if (el.fields?.length) {
+          for (const f of el.fields) {
+            html += `<p><b>${escapeHtml(f.label)}</b>: ${escapeHtml(f.value)}</p>`;
+          }
+        }
+        html += `</div>`;
+        return html;
+      }
+      case 'file':
+        return `<a href="${escapeHtml(el.url)}">${escapeHtml(el.name)}</a>`;
+      default:
+        return '';
+    }
+  }).filter(Boolean).join('\n');
+}
+
+function escapeHtml(s: string): string {
+  return s.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;');
+}

package/src/ai/providers/anthropic.ts

@@ -0,0 +1,375 @@
+/**
+ * @zhin.js/ai - Anthropic Provider
+ * 支持 Claude 系列模型
+ */
+
+import { BaseProvider } from './base.js';
+import type {
+  ProviderConfig,
+  ChatCompletionRequest,
+  ChatCompletionResponse,
+  ChatCompletionChunk,
+  ChatMessage,
+  ToolDefinition,
+  ContentPart,
+} from '../types.js';
+
+export interface AnthropicConfig extends ProviderConfig {
+  anthropicVersion?: string;
+}
+
+/**
+ * Anthropic API 格式转换
+ */
+function toAnthropicMessages(messages: ChatMessage[]): {
+  system?: string;
+  messages: any[];
+} {
+  let system: string | undefined;
+  const anthropicMessages: any[] = [];
+
+  for (const msg of messages) {
+    if (msg.role === 'system') {
+      system = typeof msg.content === 'string' 
+        ? msg.content 
+        : msg.content.map(p => p.type === 'text' ? p.text : '').join('');
+      continue;
+    }
+
+    if (msg.role === 'tool') {
+      anthropicMessages.push({
+        role: 'user',
+        content: [{
+          type: 'tool_result',
+          tool_use_id: msg.tool_call_id,
+          content: typeof msg.content === 'string' ? msg.content : JSON.stringify(msg.content),
+        }],
+      });
+      continue;
+    }
+
+    let content: any;
+    if (typeof msg.content === 'string') {
+      content = msg.content;
+    } else {
+      content = msg.content.map((part: ContentPart) => {
+        if (part.type === 'text') {
+          return { type: 'text', text: part.text };
+        }
+        if (part.type === 'image_url') {
+          // Anthropic 需要 base64 格式
+          const url = part.image_url.url;
+          if (url.startsWith('data:')) {
+            const [meta, data] = url.split(',');
+            // 使用更安全的正则表达式，避免 ReDoS
+            const mediaType = meta.match(/^data:([^;]+);/)?.[1] || 'image/png';
+            return {
+              type: 'image',
+              source: { type: 'base64', media_type: mediaType, data },
+            };
+          }
+          return {
+            type: 'image',
+            source: { type: 'url', url },
+          };
+        }
+        return { type: 'text', text: '' };
+      });
+    }
+
+    // 处理 tool_calls
+    if (msg.tool_calls?.length) {
+      const toolUseContent = msg.tool_calls.map(tc => ({
+        type: 'tool_use',
+        id: tc.id,
+        name: tc.function.name,
+        input: JSON.parse(tc.function.arguments),
+      }));
+      
+      if (typeof content === 'string' && content) {
+        content = [{ type: 'text', text: content }, ...toolUseContent];
+      } else if (Array.isArray(content)) {
+        content = [...content, ...toolUseContent];
+      } else {
+        content = toolUseContent;
+      }
+    }
+
+    anthropicMessages.push({
+      role: msg.role === 'assistant' ? 'assistant' : 'user',
+      content,
+    });
+  }
+
+  return { system, messages: anthropicMessages };
+}
+
+/**
+ * 转换工具定义
+ */
+function toAnthropicTools(tools?: ToolDefinition[]): any[] | undefined {
+  if (!tools?.length) return undefined;
+  
+  return tools.map(tool => ({
+    name: tool.function.name,
+    description: tool.function.description,
+    input_schema: tool.function.parameters,
+  }));
+}
+
+/**
+ * 转换 Anthropic 响应为 OpenAI 格式
+ */
+function fromAnthropicResponse(response: any): ChatCompletionResponse {
+  const content: ContentPart[] = [];
+  const toolCalls: any[] = [];
+
+  for (const block of response.content || []) {
+    if (block.type === 'text') {
+      content.push({ type: 'text', text: block.text });
+    } else if (block.type === 'tool_use') {
+      toolCalls.push({
+        id: block.id,
+        type: 'function',
+        function: {
+          name: block.name,
+          arguments: JSON.stringify(block.input),
+        },
+      });
+    }
+  }
+
+  const textContent = content
+    .filter(c => c.type === 'text')
+    .map(c => (c as { type: 'text'; text: string }).text)
+    .join('');
+
+  return {
+    id: response.id,
+    object: 'chat.completion',
+    created: Date.now(),
+    model: response.model,
+    choices: [{
+      index: 0,
+      message: {
+        role: 'assistant',
+        content: textContent,
+        tool_calls: toolCalls.length ? toolCalls : undefined,
+      },
+      finish_reason: response.stop_reason === 'tool_use' ? 'tool_calls' : 'stop',
+    }],
+    usage: {
+      prompt_tokens: response.usage?.input_tokens || 0,
+      completion_tokens: response.usage?.output_tokens || 0,
+      total_tokens: (response.usage?.input_tokens || 0) + (response.usage?.output_tokens || 0),
+    },
+  };
+}
+
+export class AnthropicProvider extends BaseProvider {
+  name = 'anthropic';
+  models = [
+    'claude-opus-4-20250514',
+    'claude-sonnet-4-20250514',
+    'claude-3-7-sonnet-20250219',
+    'claude-3-5-sonnet-20241022',
+    'claude-3-5-haiku-20241022',
+    'claude-3-opus-20240229',
+    'claude-3-sonnet-20240229',
+    'claude-3-haiku-20240307',
+  ];
+
+  private baseUrl: string;
+  private anthropicVersion: string;
+
+  constructor(config: AnthropicConfig = {}) {
+    super(config);
+    this.baseUrl = config.baseUrl || 'https://api.anthropic.com';
+    this.anthropicVersion = config.anthropicVersion || '2023-06-01';
+  }
+
+  protected async fetch<T>(url: string, options: RequestInit & { json?: any } = {}): Promise<T> {
+    const { json, ...fetchOptions } = options;
+    
+    const headers: Record<string, string> = {
+      'Content-Type': 'application/json',
+      'x-api-key': this.config.apiKey || '',
+      'anthropic-version': this.anthropicVersion,
+      ...this.config.headers,
+      ...(options.headers as Record<string, string>),
+    };
+
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.config.timeout);
+
+    try {
+      const response = await globalThis.fetch(url, {
+        ...fetchOptions,
+        headers,
+        body: json ? JSON.stringify(json) : fetchOptions.body,
+        signal: controller.signal,
+      });
+
+      if (!response.ok) {
+        const error = await response.text();
+        throw new Error(`Anthropic API Error (${response.status}): ${error}`);
+      }
+
+      return response.json() as Promise<T>;
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
+
+  async chat(request: ChatCompletionRequest): Promise<ChatCompletionResponse> {
+    const { system, messages } = toAnthropicMessages(request.messages);
+    
+    const anthropicRequest: any = {
+      model: request.model,
+      messages,
+      max_tokens: request.max_tokens || 4096,
+    };
+
+    if (system) {
+      anthropicRequest.system = system;
+    }
+
+    if (request.temperature !== undefined) {
+      anthropicRequest.temperature = request.temperature;
+    }
+
+    if (request.top_p !== undefined) {
+      anthropicRequest.top_p = request.top_p;
+    }
+
+    if (request.stop) {
+      anthropicRequest.stop_sequences = Array.isArray(request.stop) ? request.stop : [request.stop];
+    }
+
+    const tools = toAnthropicTools(request.tools);
+    if (tools) {
+      anthropicRequest.tools = tools;
+    }
+
+    const response = await this.fetch<any>(`${this.baseUrl}/v1/messages`, {
+      method: 'POST',
+      json: anthropicRequest,
+    });
+
+    return fromAnthropicResponse(response);
+  }
+
+  async *chatStream(request: ChatCompletionRequest): AsyncIterable<ChatCompletionChunk> {
+    const { system, messages } = toAnthropicMessages(request.messages);
+    
+    const anthropicRequest: any = {
+      model: request.model,
+      messages,
+      max_tokens: request.max_tokens || 4096,
+      stream: true,
+    };
+
+    if (system) {
+      anthropicRequest.system = system;
+    }
+
+    if (request.temperature !== undefined) {
+      anthropicRequest.temperature = request.temperature;
+    }
+
+    const tools = toAnthropicTools(request.tools);
+    if (tools) {
+      anthropicRequest.tools = tools;
+    }
+
+    const headers: Record<string, string> = {
+      'Content-Type': 'application/json',
+      'x-api-key': this.config.apiKey || '',
+      'anthropic-version': this.anthropicVersion,
+    };
+
+    const response = await globalThis.fetch(`${this.baseUrl}/v1/messages`, {
+      method: 'POST',
+      headers,
+      body: JSON.stringify(anthropicRequest),
+    });
+
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`Anthropic API Error (${response.status}): ${error}`);
+    }
+
+    if (!response.body) {
+      throw new Error('Response body is empty');
+    }
+
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = '';
+    let messageId = '';
+    let model = request.model;
+
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split('\n');
+      buffer = lines.pop() || '';
+
+      for (const line of lines) {
+        const trimmed = line.trim();
+        if (trimmed.startsWith('data: ')) {
+          const data = trimmed.slice(6);
+          if (data === '[DONE]') continue;
+
+          try {
+            const event = JSON.parse(data);
+            
+            if (event.type === 'message_start') {
+              messageId = event.message?.id || '';
+              model = event.message?.model || model;
+            } else if (event.type === 'content_block_delta') {
+              if (event.delta?.type === 'text_delta') {
+                yield {
+                  id: messageId,
+                  object: 'chat.completion.chunk',
+                  created: Date.now(),
+                  model,
+                  choices: [{
+                    index: 0,
+                    delta: { content: event.delta.text },
+                    finish_reason: null,
+                  }],
+                };
+              }
+            } else if (event.type === 'message_delta') {
+              yield {
+                id: messageId,
+                object: 'chat.completion.chunk',
+                created: Date.now(),
+                model,
+                choices: [{
+                  index: 0,
+                  delta: {},
+                  finish_reason: event.delta?.stop_reason === 'tool_use' ? 'tool_calls' : 'stop',
+                }],
+                usage: event.usage ? {
+                  prompt_tokens: event.usage.input_tokens || 0,
+                  completion_tokens: event.usage.output_tokens || 0,
+                  total_tokens: (event.usage.input_tokens || 0) + (event.usage.output_tokens || 0),
+                } : undefined,
+              };
+            }
+          } catch {
+            // 忽略解析错误
+          }
+        }
+      }
+    }
+  }
+
+  async listModels(): Promise<string[]> {
+    return this.models;
+  }
+}