ai-agent-router 0.2.2 → 0.2.4

package/dist/src/server/tokenizer.js

@@ -0,0 +1,215 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.estimateTokenCount = estimateTokenCount;
+exports.buildTokenizerRequest = buildTokenizerRequest;
+exports.runTokenizerRequest = runTokenizerRequest;
+exports.extractResponseText = extractResponseText;
+exports.normalizeUsage = normalizeUsage;
+const providers_1 = require("@/server/providers");
+function estimateTokenCount(text) {
+    const normalized = (text || '').trim();
+    if (!normalized)
+        return 0;
+    return Math.max(1, Math.ceil(normalized.length / 4));
+}
+function buildTokenizerRequest(args) {
+    const { protocol, modelId, mode, sourceLanguage, targetLanguage, text, temperature = 0, topP = 1, } = args;
+    const exactRepeatInstruction = 'Repeat the user input exactly as provided. Output only the original user input with no additions, no deletions, no translations, no explanations, no formatting changes, and no extra quotes.';
+    if (protocol === 'openai') {
+        const messages = mode === 'measure'
+            ? [
+                { role: 'system', content: exactRepeatInstruction },
+                { role: 'user', content: text },
+            ]
+            : [
+                {
+                    role: 'system',
+                    content: `Translate the user input from ${sourceLanguage} to ${targetLanguage}. Return only the translated text.`,
+                },
+                { role: 'user', content: text },
+            ];
+        return {
+            method: 'POST',
+            path: '/v1/chat/completions',
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            query: {},
+            body: {
+                model: modelId,
+                messages,
+                stream: false,
+                temperature,
+                top_p: topP,
+            },
+        };
+    }
+    if (protocol === 'anthropic') {
+        const messages = mode === 'measure'
+            ? [{ role: 'user', content: text }]
+            : [
+                {
+                    role: 'user',
+                    content: `Translate the following ${sourceLanguage} text into ${targetLanguage}. Return only the translated text.\n\n${text}`,
+                },
+            ];
+        return {
+            method: 'POST',
+            path: '/v1/messages',
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            query: {},
+            body: {
+                model: modelId,
+                system: mode === 'measure' ? exactRepeatInstruction : undefined,
+                messages,
+                temperature,
+                top_p: topP,
+            },
+        };
+    }
+    return {
+        method: 'POST',
+        path: `/v1/models/${modelId}:generateContent`,
+        headers: {
+            'Content-Type': 'application/json',
+        },
+        query: {},
+        body: {
+            contents: [
+                {
+                    parts: [
+                        {
+                            text: mode === 'measure'
+                                ? text
+                                : `Translate the following ${sourceLanguage} text into ${targetLanguage}. Return only the translated text.\n\n${text}`,
+                        },
+                    ],
+                },
+            ],
+            systemInstruction: {
+                parts: [
+                    {
+                        text: mode === 'measure' ? exactRepeatInstruction : 'You are a precise translator.',
+                    },
+                ],
+            },
+            generationConfig: {
+                temperature,
+                topP,
+            },
+        },
+    };
+}
+async function runTokenizerRequest(model, request, inputText) {
+    const adapter = (0, providers_1.getProviderAdapter)(model.provider.protocol);
+    const response = await adapter.forwardRequest(model, request);
+    if (response.status < 200 || response.status >= 300) {
+        const errorMessage = extractErrorMessage(response) || 'Tokenizer request failed';
+        throw new Error(errorMessage);
+    }
+    const text = extractResponseText(model.provider.protocol, response.body);
+    const usage = normalizeUsage(model.provider.protocol, response.body, inputText, text);
+    return {
+        text,
+        usage,
+        raw: response.body,
+    };
+}
+function extractErrorMessage(response) {
+    const { body } = response;
+    if (!body)
+        return null;
+    if (typeof body === 'string')
+        return body;
+    if (body.error?.message)
+        return body.error.message;
+    if (body.message)
+        return body.message;
+    return null;
+}
+function extractResponseText(protocol, body) {
+    if (!body)
+        return '';
+    if (protocol === 'openai') {
+        return (body?.choices?.[0]?.message?.content ??
+            body?.choices?.[0]?.text ??
+            '').toString();
+    }
+    if (protocol === 'anthropic') {
+        const content = body?.content;
+        if (Array.isArray(content)) {
+            return content
+                .map((item) => item?.text || '')
+                .join('\n');
+        }
+        return '';
+    }
+    const candidateText = body?.candidates?.[0]?.content?.parts?.map((part) => part?.text || '').join('\n') ??
+        body?.text ??
+        '';
+    return candidateText.toString();
+}
+function normalizeUsage(protocol, body, inputText, outputText) {
+    const promptEstimate = estimateTokenCount(inputText);
+    const completionEstimate = estimateTokenCount(outputText);
+    if (protocol === 'openai') {
+        const usage = body?.usage;
+        if (usage) {
+            const input = toNumber(usage.prompt_tokens ?? usage.input_tokens);
+            const output = toNumber(usage.completion_tokens ?? usage.output_tokens);
+            const total = toNumber(usage.total_tokens) || input + output;
+            if (input || output || total) {
+                return {
+                    input_tokens: input,
+                    output_tokens: output,
+                    total_tokens: total,
+                    estimated: false,
+                };
+            }
+        }
+    }
+    if (protocol === 'anthropic') {
+        const usage = body?.usage;
+        if (usage) {
+            const input = toNumber(usage.input_tokens ?? usage.prompt_tokens);
+            const output = toNumber(usage.output_tokens ?? usage.completion_tokens);
+            const total = input + output;
+            if (input || output) {
+                return {
+                    input_tokens: input,
+                    output_tokens: output,
+                    total_tokens: total,
+                    estimated: false,
+                };
+            }
+        }
+    }
+    if (protocol === 'gemini') {
+        const usage = body?.usageMetadata ?? body?.usage;
+        if (usage) {
+            const input = toNumber(usage.promptTokenCount ?? usage.input_tokens ?? usage.prompt_tokens);
+            const output = toNumber(usage.candidatesTokenCount ?? usage.output_tokens ?? usage.completion_tokens);
+            const total = toNumber(usage.totalTokenCount ?? usage.total_tokens) || input + output;
+            if (input || output || total) {
+                return {
+                    input_tokens: input,
+                    output_tokens: output,
+                    total_tokens: total,
+                    estimated: false,
+                };
+            }
+        }
+    }
+    return {
+        input_tokens: promptEstimate,
+        output_tokens: completionEstimate,
+        total_tokens: promptEstimate + completionEstimate,
+        estimated: true,
+    };
+}
+function toNumber(value) {
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : 0;
+}

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "ai-agent-router",
-  "version": "0.2.2",
+  "version": "0.2.4",
   "description": "A unified API gateway for managing multiple AI model providers (Anthropic, OpenAI, Gemini, etc.)",
   "main": "dist/src/cli/index.js",
   "bin": {
-    "aar": "./dist/src/cli/index.js"
+    "aar": "./dist/src/cli/index.js",
+    "ai-agent-router": "./dist/src/cli/index.js"
   },
   "scripts": {
     "dev": "next dev -p 9527",

package/src/app/api/tokenizer/history/route.ts

@@ -0,0 +1,63 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { getDatabase } from '@/db/database';
+import { getTokenizerLogs, getTokenizerLogCount } from '@/db/queries';
+
+export const runtime = 'nodejs';
+export const dynamic = 'force-dynamic';
+
+export async function GET(request: NextRequest) {
+  try {
+    await getDatabase();
+    const { searchParams } = new URL(request.url);
+    const limit = parseInt(searchParams.get('limit') || '50', 10);
+    const offset = parseInt(searchParams.get('offset') || '0', 10);
+
+    const logs = await getTokenizerLogs(limit, offset);
+    const total = await getTokenizerLogCount();
+
+    return NextResponse.json({
+      logs: logs.map(mapTokenizerLog),
+      total,
+      limit,
+      offset,
+    });
+  } catch (error: any) {
+    console.error('Tokenizer history API error:', error);
+    return NextResponse.json(
+      { error: error.message || 'Internal server error' },
+      { status: 500 }
+    );
+  }
+}
+
+function mapTokenizerLog(log: any) {
+  const requestBody = parseJson(log.request_body);
+  const responseBody = parseJson(log.response_body);
+
+  return {
+    id: log.id,
+    created_at: log.created_at,
+    status: log.response_status,
+    response_time_ms: responseBody?.response_time_ms ?? log.response_time_ms ?? null,
+    mode: requestBody?.mode ?? null,
+    source_language: requestBody?.source_language ?? null,
+    target_language: requestBody?.target_language ?? null,
+    source_text: requestBody?.text ?? '',
+    result_text: responseBody?.text ?? '',
+    usage: responseBody?.usage ?? null,
+    model_name: responseBody?.model?.name ?? log.model_name ?? null,
+    model_id: responseBody?.model?.model_id ?? log.model_id ?? null,
+    provider_name: responseBody?.model?.provider_name ?? log.provider_name ?? null,
+  };
+}
+
+function parseJson(value: any) {
+  if (!value) return null;
+  if (typeof value === 'object') return value;
+
+  try {
+    return JSON.parse(value);
+  } catch {
+    return null;
+  }
+}

package/src/app/api/tokenizer/test/route.ts

@@ -0,0 +1,151 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { getDatabase } from '@/db/database';
+import { getModelById, getProviderById } from '@/db/queries';
+import {
+  buildTokenizerRequest,
+  runTokenizerRequest,
+  type TokenizerMode,
+} from '@/server/tokenizer';
+import { logRequest } from '@/server/logger';
+
+export const runtime = 'nodejs';
+
+export async function POST(request: NextRequest) {
+  const startedAt = Date.now();
+  let logPayload: any = null;
+
+  try {
+    await getDatabase();
+
+    const body = await request.json();
+    const {
+      model_id,
+      mode,
+      source_language,
+      target_language,
+      text,
+      temperature,
+      top_p,
+    }: {
+      model_id?: number;
+      mode?: TokenizerMode;
+      source_language?: string;
+      target_language?: string;
+      text?: string;
+      temperature?: number;
+      top_p?: number;
+    } = body;
+
+    logPayload = body;
+
+    if (!model_id || !mode || !source_language || !text?.trim()) {
+      return NextResponse.json(
+        { error: 'model_id, mode, source_language and text are required' },
+        { status: 400 }
+      );
+    }
+
+    if (mode !== 'measure' && mode !== 'translate') {
+      return NextResponse.json(
+        { error: 'mode must be measure or translate' },
+        { status: 400 }
+      );
+    }
+
+    if (mode === 'translate' && !target_language) {
+      return NextResponse.json(
+        { error: 'target_language is required for translate mode' },
+        { status: 400 }
+      );
+    }
+
+    const model = await getModelById(model_id);
+    if (!model) {
+      return NextResponse.json({ error: 'Model not found' }, { status: 404 });
+    }
+
+    const provider = await getProviderById(model.provider_id);
+    if (!provider) {
+      return NextResponse.json({ error: 'Provider not found' }, { status: 404 });
+    }
+
+    const tokenizerRequest = buildTokenizerRequest({
+      protocol: provider.protocol,
+      modelId: model.model_id,
+      mode,
+      sourceLanguage: source_language,
+      targetLanguage: target_language,
+      text,
+      temperature,
+      topP: top_p,
+    });
+
+    const result = await runTokenizerRequest(
+      { ...model, provider },
+      tokenizerRequest,
+      text
+    );
+
+    const responseTimeMs = Date.now() - startedAt;
+    const responseBody = {
+      success: true,
+      mode,
+      provider_protocol: provider.protocol,
+      model: {
+        id: model.id,
+        name: model.name,
+        model_id: model.model_id,
+        provider_name: provider.name,
+      },
+      text: result.text,
+      usage: result.usage,
+      response_time_ms: responseTimeMs,
+    };
+
+    await logRequest(
+      {
+        modelId: model.id,
+        method: 'POST',
+        path: '/tokenizer/test',
+        headers: { 'content-type': 'application/json' },
+        query: {},
+        body: logPayload,
+      },
+      {
+        status: 200,
+        headers: { 'content-type': 'application/json' },
+        body: responseBody,
+        responseTimeMs,
+      }
+    );
+
+    return NextResponse.json(responseBody);
+  } catch (error: any) {
+    console.error('Tokenizer API error:', error);
+    const responseTimeMs = Date.now() - startedAt;
+
+    if (logPayload?.model_id) {
+      await logRequest(
+        {
+          modelId: Number(logPayload.model_id) || null,
+          method: 'POST',
+          path: '/tokenizer/test',
+          headers: { 'content-type': 'application/json' },
+          query: {},
+          body: logPayload,
+        },
+        {
+          status: 500,
+          headers: { 'content-type': 'application/json' },
+          body: { error: error.message || 'Internal server error' },
+          responseTimeMs,
+        }
+      );
+    }
+
+    return NextResponse.json(
+      { error: error.message || 'Internal server error' },
+      { status: 500 }
+    );
+  }
+}

package/src/app/components/Nav.tsx

@@ -11,6 +11,7 @@ export default function Nav() {
     { href: '/ide', label: 'IDE' },
     { href: '/providers', label: '供应商' },
     { href: '/models', label: '模型' },
+    { href: '/tokenizer', label: 'Tokenizer' },
     { href: '/logs', label: '日志' },
   ];
 
@@ -34,8 +35,7 @@ export default function Nav() {
                   <Link
                     key={item.href}
                     href={item.href}
-                    className="relative inline-flex items-center justify-center w-[68px] h-9 text-xs font-medium transition-colors duration-300 group"
-                    style={{ minWidth: '68px', maxWidth: '68px' }}
+                    className="relative inline-flex items-center justify-center min-w-[68px] px-3 h-9 text-xs font-medium transition-colors duration-300 group"
                   >
                     {/* 固定宽度和高度，完全避免抖动 - 使用绝对定位确保位置不变 */}
                     <span