@nahisaho/katashiro-llm 2.0.0

package/src/TokenCounter.ts

@@ -0,0 +1,114 @@
+/**
+ * Token Counter - トークン数カウント
+ *
+ * @requirement REQ-LLM-001
+ * @design DES-KATASHIRO-003-LLM §3.1
+ */
+
+/**
+ * モデル別トークン推定係数
+ */
+const MODEL_TOKEN_FACTORS: Record<string, number> = {
+  'gpt-4o': 4.0,
+  'gpt-4o-mini': 4.0,
+  'gpt-4-turbo': 4.0,
+  'gpt-4': 4.0,
+  'gpt-3.5-turbo': 4.0,
+  'claude-3-5-sonnet': 4.5,
+  'claude-3-opus': 4.5,
+  'claude-3-sonnet': 4.5,
+  'claude-3-haiku': 4.5,
+  'gemini-pro': 4.0,
+  'gemini-1.5-pro': 4.0,
+  default: 4.0,
+};
+
+/**
+ * TokenCounter - トークン数カウントユーティリティ
+ */
+export class TokenCounter {
+  /**
+   * テキストのトークン数を推定
+   */
+  estimate(text: string, model?: string): number {
+    const factor = this.getTokenFactor(model);
+    return Math.ceil(text.length / factor);
+  }
+
+  /**
+   * メッセージ配列のトークン数を推定
+   */
+  estimateMessages(
+    messages: Array<{ role: string; content: string }>,
+    model?: string
+  ): number {
+    let total = 0;
+    for (const message of messages) {
+      // ロールのオーバーヘッド（約4トークン）
+      total += 4;
+      total += this.estimate(message.content, model);
+    }
+    // メッセージ区切りのオーバーヘッド
+    total += 3;
+    return total;
+  }
+
+  /**
+   * トークン数が制限内か確認
+   */
+  isWithinLimit(text: string, limit: number, model?: string): boolean {
+    return this.estimate(text, model) <= limit;
+  }
+
+  /**
+   * 制限内に収まるようにテキストを切り詰め
+   */
+  truncateToLimit(text: string, limit: number, model?: string): string {
+    const currentTokens = this.estimate(text, model);
+    if (currentTokens <= limit) {
+      return text;
+    }
+
+    const factor = this.getTokenFactor(model);
+    const targetLength = Math.floor(limit * factor * 0.9); // 10%マージン
+    return text.slice(0, targetLength) + '...';
+  }
+
+  /**
+   * モデル別トークン係数取得
+   */
+  private getTokenFactor(model?: string): number {
+    if (!model) {
+      return MODEL_TOKEN_FACTORS.default ?? 4.0;
+    }
+
+    // モデル名の部分一致
+    for (const [key, factor] of Object.entries(MODEL_TOKEN_FACTORS)) {
+      if (model.includes(key)) {
+        return factor;
+      }
+    }
+
+    return MODEL_TOKEN_FACTORS.default ?? 4.0;
+  }
+}
+
+// シングルトン
+let tokenCounterInstance: TokenCounter | null = null;
+
+/**
+ * TokenCounter シングルトン取得
+ */
+export function getTokenCounter(): TokenCounter {
+  if (!tokenCounterInstance) {
+    tokenCounterInstance = new TokenCounter();
+  }
+  return tokenCounterInstance;
+}
+
+/**
+ * TokenCounter リセット（テスト用）
+ */
+export function resetTokenCounter(): void {
+  tokenCounterInstance = null;
+}

package/src/index.ts

@@ -0,0 +1,35 @@
+/**
+ * LLM Package - Main Entry Point
+ *
+ * @requirement REQ-LLM-001〜006
+ * @design DES-KATASHIRO-003-LLM
+ */
+
+// Types
+export * from './types.js';
+
+// Providers
+export * from './providers/index.js';
+
+// Client
+export {
+  LLMClient,
+  getLLMClient,
+  initLLMClient,
+  resetLLMClient,
+} from './LLMClient.js';
+
+// Prompt Manager
+export {
+  PromptManager,
+  getPromptManager,
+  resetPromptManager,
+  type TemplateVariables,
+} from './PromptManager.js';
+
+// Token Counter
+export {
+  TokenCounter,
+  getTokenCounter,
+  resetTokenCounter,
+} from './TokenCounter.js';

package/src/providers/AzureOpenAILLMProvider.ts

@@ -0,0 +1,494 @@
+/**
+ * Azure OpenAI LLM Provider
+ *
+ * Azure OpenAI Service provider for chat completions
+ *
+ * @requirement REQ-LLM-001
+ * @design DES-KATASHIRO-003-LLM
+ */
+
+import type { z, ZodType } from 'zod';
+import type {
+  ProviderConfig,
+  GenerateRequest,
+  GenerateResponse,
+  StreamChunk,
+  Message,
+  TokenUsage,
+  ToolCall,
+  ToolDefinition,
+  FinishReason,
+} from '../types.js';
+import { BaseLLMProvider } from './BaseLLMProvider.js';
+
+/**
+ * Azure OpenAI設定
+ */
+export interface AzureOpenAIProviderConfig extends ProviderConfig {
+  /** Azure OpenAI エンドポイント */
+  endpoint?: string;
+  /** APIキー */
+  apiKey?: string;
+  /** デプロイメント名 */
+  deploymentName?: string;
+  /** APIバージョン */
+  apiVersion?: string;
+}
+
+/**
+ * Azure OpenAIメッセージ形式
+ */
+interface AzureMessage {
+  role: 'system' | 'user' | 'assistant' | 'tool';
+  content: string | null;
+  name?: string;
+  tool_call_id?: string;
+  tool_calls?: Array<{
+    id: string;
+    type: 'function';
+    function: {
+      name: string;
+      arguments: string;
+    };
+  }>;
+}
+
+/**
+ * Azure Chat Completion レスポンス
+ */
+interface AzureChatResponse {
+  id: string;
+  object: 'chat.completion';
+  created: number;
+  model: string;
+  choices: Array<{
+    index: number;
+    message: AzureMessage;
+    finish_reason: 'stop' | 'length' | 'tool_calls' | 'content_filter';
+  }>;
+  usage: {
+    prompt_tokens: number;
+    completion_tokens: number;
+    total_tokens: number;
+  };
+}
+
+/**
+ * Azure Stream Chunk
+ */
+interface AzureStreamChunk {
+  id: string;
+  object: 'chat.completion.chunk';
+  created: number;
+  model: string;
+  choices: Array<{
+    index: number;
+    delta: {
+      role?: string;
+      content?: string;
+      tool_calls?: Array<{
+        index: number;
+        id?: string;
+        type?: 'function';
+        function?: {
+          name?: string;
+          arguments?: string;
+        };
+      }>;
+    };
+    finish_reason: string | null;
+  }>;
+  usage?: {
+    prompt_tokens: number;
+    completion_tokens: number;
+    total_tokens: number;
+  };
+}
+
+/**
+ * Azure OpenAI LLMプロバイダー
+ *
+ * Azure OpenAI Serviceを使用したテキスト生成
+ *
+ * @example
+ * ```typescript
+ * const provider = new AzureOpenAILLMProvider({
+ *   endpoint: 'https://your-resource.openai.azure.com',
+ *   apiKey: process.env.AZURE_OPENAI_API_KEY,
+ *   deploymentName: 'gpt-4o',
+ *   apiVersion: '2024-02-15-preview',
+ * });
+ *
+ * const response = await provider.generate({
+ *   messages: [{ role: 'user', content: 'Hello!' }],
+ * });
+ * ```
+ */
+export class AzureOpenAILLMProvider extends BaseLLMProvider {
+  readonly name = 'azure-openai';
+  readonly supportedModels = [
+    'gpt-4o',
+    'gpt-4o-mini',
+    'gpt-4-turbo',
+    'gpt-4',
+    'gpt-35-turbo',
+  ];
+
+  private readonly endpoint: string;
+  private readonly apiKey: string;
+  private readonly deploymentName: string;
+  private readonly apiVersion: string;
+
+  constructor(config: AzureOpenAIProviderConfig = {}) {
+    super(config);
+
+    this.endpoint = config.endpoint ?? process.env.AZURE_OPENAI_ENDPOINT ?? '';
+    this.apiKey = config.apiKey ?? process.env.AZURE_OPENAI_API_KEY ?? '';
+    this.deploymentName =
+      config.deploymentName ??
+      process.env.AZURE_OPENAI_DEPLOYMENT ??
+      config.defaultModel ??
+      '';
+    this.apiVersion = config.apiVersion ?? '2024-02-15-preview';
+
+    // 設定検証
+    if (!this.endpoint) {
+      throw new Error(
+        'Azure OpenAI endpoint is required. Set AZURE_OPENAI_ENDPOINT or provide endpoint in config.'
+      );
+    }
+    if (!this.apiKey) {
+      throw new Error(
+        'Azure OpenAI API key is required. Set AZURE_OPENAI_API_KEY or provide apiKey in config.'
+      );
+    }
+    if (!this.deploymentName) {
+      throw new Error(
+        'Azure OpenAI deployment name is required. Set AZURE_OPENAI_DEPLOYMENT or provide deploymentName in config.'
+      );
+    }
+  }
+
+  protected getDefaultModel(): string {
+    return this.deploymentName;
+  }
+
+  /**
+   * メッセージ形式変換
+   */
+  private convertMessages(messages: Message[]): AzureMessage[] {
+    return messages.map((msg) => {
+      const converted: AzureMessage = {
+        role: msg.role,
+        content:
+          typeof msg.content === 'string'
+            ? msg.content
+            : JSON.stringify(msg.content),
+      };
+
+      if (msg.name) converted.name = msg.name;
+      if (msg.toolCallId) converted.tool_call_id = msg.toolCallId;
+      if (msg.toolCalls) {
+        converted.tool_calls = msg.toolCalls.map((tc) => ({
+          id: tc.id,
+          type: tc.type,
+          function: tc.function,
+        }));
+      }
+
+      return converted;
+    });
+  }
+
+  /**
+   * ツール定義変換
+   */
+  private convertTools(tools?: ToolDefinition[]): unknown[] | undefined {
+    if (!tools) return undefined;
+
+    return tools.map((tool) => ({
+      type: tool.type,
+      function: {
+        name: tool.function.name,
+        description: tool.function.description,
+        parameters: tool.function.parameters,
+      },
+    }));
+  }
+
+  /**
+   * Finish Reason変換
+   */
+  private convertFinishReason(reason: string | null): FinishReason {
+    switch (reason) {
+      case 'stop':
+        return 'stop';
+      case 'length':
+        return 'length';
+      case 'tool_calls':
+        return 'tool_calls';
+      case 'content_filter':
+        return 'content_filter';
+      default:
+        return 'stop';
+    }
+  }
+
+  /**
+   * テキスト生成
+   */
+  async generate(request: GenerateRequest): Promise<GenerateResponse> {
+    const baseUrl = this.endpoint.endsWith('/')
+      ? this.endpoint.slice(0, -1)
+      : this.endpoint;
+
+    const url = `${baseUrl}/openai/deployments/${this.deploymentName}/chat/completions?api-version=${this.apiVersion}`;
+
+    const headers: Record<string, string> = {
+      'Content-Type': 'application/json',
+      'api-key': this.apiKey,
+    };
+
+    const body: Record<string, unknown> = {
+      messages: this.convertMessages(request.messages),
+      temperature: request.temperature,
+      max_tokens: request.maxTokens,
+      top_p: request.topP,
+      stop: request.stopSequences,
+      user: request.user,
+    };
+
+    if (request.tools) {
+      body.tools = this.convertTools(request.tools);
+      body.tool_choice = request.toolChoice;
+    }
+
+    if (request.responseFormat) {
+      body.response_format = {
+        type: request.responseFormat.type,
+      };
+    }
+
+    const controller = new AbortController();
+    const timeoutId = setTimeout(
+      () => controller.abort(),
+      this.config.timeout ?? 30000
+    );
+
+    try {
+      const response = await fetch(url, {
+        method: 'POST',
+        headers,
+        body: JSON.stringify(body),
+        signal: controller.signal,
+      });
+
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(
+          `Azure OpenAI API error: ${response.status} - ${errorText}`
+        );
+      }
+
+      const data = (await response.json()) as AzureChatResponse;
+      const choice = data.choices[0];
+
+      if (!choice) {
+        throw new Error('No choices returned from Azure OpenAI API');
+      }
+
+      const toolCalls: ToolCall[] | undefined = choice.message.tool_calls?.map(
+        (tc) => ({
+          id: tc.id,
+          type: tc.type,
+          function: tc.function,
+        })
+      );
+
+      const usage: TokenUsage = {
+        promptTokens: data.usage.prompt_tokens,
+        completionTokens: data.usage.completion_tokens,
+        totalTokens: data.usage.total_tokens,
+      };
+
+      return {
+        id: data.id,
+        model: data.model,
+        content: choice.message.content ?? '',
+        toolCalls,
+        usage,
+        finishReason: this.convertFinishReason(choice.finish_reason),
+      };
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
+
+  /**
+   * ストリーミング生成
+   */
+  async *generateStream(request: GenerateRequest): AsyncGenerator<StreamChunk> {
+    const baseUrl = this.endpoint.endsWith('/')
+      ? this.endpoint.slice(0, -1)
+      : this.endpoint;
+
+    const url = `${baseUrl}/openai/deployments/${this.deploymentName}/chat/completions?api-version=${this.apiVersion}`;
+
+    const headers: Record<string, string> = {
+      'Content-Type': 'application/json',
+      'api-key': this.apiKey,
+    };
+
+    const body: Record<string, unknown> = {
+      messages: this.convertMessages(request.messages),
+      temperature: request.temperature,
+      max_tokens: request.maxTokens,
+      top_p: request.topP,
+      stop: request.stopSequences,
+      user: request.user,
+      stream: true,
+    };
+
+    if (request.tools) {
+      body.tools = this.convertTools(request.tools);
+      body.tool_choice = request.toolChoice;
+    }
+
+    const response = await fetch(url, {
+      method: 'POST',
+      headers,
+      body: JSON.stringify(body),
+    });
+
+    if (!response.ok || !response.body) {
+      const errorText = await response.text();
+      throw new Error(
+        `Azure OpenAI API error: ${response.status} - ${errorText}`
+      );
+    }
+
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = '';
+
+    const toolCallsMap = new Map<
+      number,
+      { id: string; name: string; arguments: string }
+    >();
+
+    try {
+      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) {
+          if (!line.startsWith('data: ')) continue;
+          const data = line.slice(6).trim();
+          if (data === '[DONE]') {
+            yield { type: 'done' };
+            continue;
+          }
+
+          try {
+            const chunk = JSON.parse(data) as AzureStreamChunk;
+            const delta = chunk.choices[0]?.delta;
+
+            if (delta?.content) {
+              yield {
+                type: 'content',
+                content: delta.content,
+              };
+            }
+
+            if (delta?.tool_calls) {
+              for (const tc of delta.tool_calls) {
+                const existing = toolCallsMap.get(tc.index) ?? {
+                  id: '',
+                  name: '',
+                  arguments: '',
+                };
+                if (tc.id) existing.id = tc.id;
+                if (tc.function?.name) existing.name = tc.function.name;
+                if (tc.function?.arguments) {
+                  existing.arguments += tc.function.arguments;
+                }
+                toolCallsMap.set(tc.index, existing);
+              }
+            }
+
+            if (chunk.usage) {
+              yield {
+                type: 'usage',
+                usage: {
+                  promptTokens: chunk.usage.prompt_tokens,
+                  completionTokens: chunk.usage.completion_tokens,
+                  totalTokens: chunk.usage.total_tokens,
+                },
+              };
+            }
+
+            const finishReason = chunk.choices[0]?.finish_reason;
+            if (finishReason === 'tool_calls') {
+              for (const [, tc] of toolCallsMap) {
+                yield {
+                  type: 'tool_call',
+                  toolCall: {
+                    id: tc.id,
+                    type: 'function',
+                    function: {
+                      name: tc.name,
+                      arguments: tc.arguments,
+                    },
+                  },
+                };
+              }
+            }
+          } catch {
+            // JSON parse error - skip
+          }
+        }
+      }
+    } finally {
+      reader.releaseLock();
+    }
+  }
+
+  /**
+   * 構造化出力生成
+   */
+  override async generateStructured<T extends ZodType>(
+    request: GenerateRequest,
+    schema: T
+  ): Promise<z.infer<T>> {
+    const jsonSchema = this.zodToJsonSchema(schema);
+
+    const enhancedRequest: GenerateRequest = {
+      ...request,
+      responseFormat: { type: 'json_object' },
+      messages: [
+        ...request.messages,
+        {
+          role: 'user',
+          content: `Respond with valid JSON matching this schema:\n${JSON.stringify(jsonSchema, null, 2)}`,
+        },
+      ],
+    };
+
+    const response = await this.generate(enhancedRequest);
+    const parsed = JSON.parse(response.content);
+    return schema.parse(parsed);
+  }
+
+  /**
+   * トークン数カウント（近似）
+   */
+  override async countTokens(text: string, _model?: string): Promise<number> {
+    const englishChars = text.replace(/[^\x00-\x7F]/g, '').length;
+    const nonEnglishChars = text.length - englishChars;
+    return Math.ceil(englishChars / 4 + nonEnglishChars / 2);
+  }
+}