plugin-ai-api 1.0.8 → 1.0.10

package/src/server/usage.ts

@@ -0,0 +1,55 @@
+import { Context } from '@nocobase/actions';
+
+type Usage = { prompt_tokens?: number; completion_tokens?: number; total_tokens?: number };
+
+export async function startUsageRecord(
+  ctx: Context,
+  requestId: string,
+  endpoint: string,
+  model: string,
+  streaming: boolean,
+) {
+  const body = (ctx.request.body || {}) as Record<string, unknown>;
+  const messages = Array.isArray(body.messages) ? body.messages : undefined;
+  const oauth = ctx.state.oauthPrincipal as { clientId?: string; subject?: string; scopes?: string[] } | undefined;
+  const record = await ctx.db.getRepository('aiApiUsageRecords').create({
+    values: {
+      requestId,
+      userId: String(ctx.state.currentUser?.id),
+      roleName: ctx.state.currentRole || ctx.state.currentRoles?.[0] || 'unknown',
+      authType: ctx.state.aiApiAuthType || (oauth ? 'oidc' : 'session'),
+      oauthClientId: oauth?.clientId,
+      oauthSubject: oauth?.subject,
+      oauthScopes: oauth?.scopes,
+      endpoint,
+      mode: ctx.get('X-AI-Mode') || undefined,
+      model: model === '-' ? undefined : model,
+      status: 'pending',
+      streaming,
+      startedAt: new Date(),
+      requestMetadata: { messageCount: messages?.length, requestedMaxTokens: body.max_tokens },
+    },
+  });
+  return record.id;
+}
+
+export async function finishUsageRecord(ctx: Context, id: unknown, startedAt: number, status: 'succeeded' | 'failed') {
+  const response = (ctx.body || {}) as { usage?: Usage; id?: string; error?: { code?: string } };
+  const streamResult = ctx.state.aiApiStreamResult as
+    | { usage?: Usage; id?: string; errorCode?: string; succeeded: boolean }
+    | undefined;
+  const usage = response.usage || streamResult?.usage;
+  const values = {
+    status: streamResult ? (streamResult.succeeded ? 'succeeded' : 'failed') : status,
+    httpStatus: ctx.status,
+    errorCode: response.error?.code || streamResult?.errorCode,
+    inputTokens: usage?.prompt_tokens,
+    outputTokens: usage?.completion_tokens,
+    totalTokens: usage?.total_tokens,
+    providerRequestId: response.id || streamResult?.id,
+    completedAt: new Date(),
+    durationMs: Date.now() - startedAt,
+    responseMetadata: { usageSource: usage ? 'response' : 'unavailable' },
+  };
+  await ctx.db.getRepository('aiApiUsageRecords').update({ filterByTk: id, values });
+}

package/src/server/utils/ai-employee-runtime.ts

@@ -15,7 +15,7 @@ interface AIEmployeeConstructorOptions {
 }
 
 interface AIEmployeeRuntime {
-  stream(options: { userMessages: unknown[] }): Promise<void>;
+  stream(options: { userMessages: unknown[] }): Promise<boolean>;
   invoke(options: { userMessages: unknown[] }): Promise<unknown>;
 }
 

package/src/server/utils/openai-format.ts

@@ -1,142 +1,164 @@
-/**
- * This file is part of the NocoBase (R) project.
- * Copyright (c) 2020-2024 NocoBase Co., Ltd.
- * Authors: NocoBase Team.
- *
- * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
- * For more information, please refer to: https://www.nocobase.com/agreement.
- */
-
-import crypto from 'crypto';
-
-// ─── Model string parsing ───
-
-export interface ParsedModel {
-  llmService: string;
-  modelId: string;
-}
-
-/**
- * Parse OpenAI-style model string into NocoBase llmService + modelId.
- * Format: "llmServiceName/modelId" (e.g. "my-openai/gpt-4o")
- * If no "/" is present, the entire string is treated as modelId and llmService is empty.
- */
-export function parseModelString(model: string): ParsedModel {
-  const slashIndex = model.indexOf('/');
-  if (slashIndex === -1) {
-    return { llmService: '', modelId: model };
-  }
-  return {
-    llmService: model.substring(0, slashIndex),
-    modelId: model.substring(slashIndex + 1),
-  };
-}
-
-// ─── ID generation ───
-
-export function generateCompletionId(): string {
-  return `chatcmpl-${crypto.randomBytes(16).toString('hex').substring(0, 29)}`;
-}
-
-// ─── OpenAI error format ───
-
-export function toOpenAIError(statusCode: number, message: string, type = 'invalid_request_error', code?: string) {
-  return {
-    error: {
-      message,
-      type,
-      param: null,
-      code: code || null,
-    },
-  };
-}
-
-// ─── OpenAI Chat Completion response (non-streaming) ───
-
-export function toOpenAIResponse(options: {
-  id: string;
-  model: string;
-  content: string;
-  finishReason?: string;
-  usage?: { prompt_tokens?: number; completion_tokens?: number; total_tokens?: number };
-}) {
-  const { id, model, content, finishReason = 'stop', usage } = options;
-  return {
-    id,
-    object: 'chat.completion',
-    created: Math.floor(Date.now() / 1000),
-    model,
-    system_fingerprint: null,
-    choices: [
-      {
-        index: 0,
-        message: {
-          role: 'assistant',
-          content,
-        },
-        logprobs: null,
-        finish_reason: finishReason,
-      },
-    ],
-    usage: usage || { prompt_tokens: 0, completion_tokens: 0, total_tokens: 0 },
-  };
-}
-
-// ─── OpenAI Streaming chunk format ───
-
-export function toOpenAIStreamChunk(options: {
-  id: string;
-  model: string;
-  delta: { role?: string; content?: string };
-  finishReason?: string | null;
-}) {
-  const { id, model, delta, finishReason = null } = options;
-  return {
-    id,
-    object: 'chat.completion.chunk',
-    created: Math.floor(Date.now() / 1000),
-    model,
-    system_fingerprint: null,
-    choices: [
-      {
-        index: 0,
-        delta,
-        logprobs: null,
-        finish_reason: finishReason,
-      },
-    ],
-  };
-}
-
-// ─── OpenAI Embeddings response ───
-
-export function toOpenAIEmbeddingsResponse(options: { model: string; embeddings: number[][]; promptTokens?: number }) {
-  const { model, embeddings, promptTokens = 0 } = options;
-  return {
-    object: 'list' as const,
-    data: embeddings.map((embedding, index) => ({
-      object: 'embedding' as const,
-      embedding,
-      index,
-    })),
-    model,
-    usage: {
-      prompt_tokens: promptTokens,
-      total_tokens: promptTokens,
-    },
-  };
-}
-
-/**
- * Format a streaming chunk as an SSE data line.
- */
-export function formatSSE(data: any): string {
-  return `data: ${JSON.stringify(data)}\n\n`;
-}
-
-/**
- * Format the terminal SSE [DONE] signal.
- */
-export function formatSSEDone(): string {
-  return `data: [DONE]\n\n`;
-}
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+
+import crypto from 'crypto';
+
+// ─── Model string parsing ───
+
+export interface ParsedModel {
+  llmService: string;
+  modelId: string;
+}
+
+/**
+ * Parse OpenAI-style model string into NocoBase llmService + modelId.
+ * Format: "llmServiceName/modelId" (e.g. "my-openai/gpt-4o")
+ * If no "/" is present, the entire string is treated as modelId and llmService is empty.
+ */
+export function parseModelString(model: string): ParsedModel {
+  const slashIndex = model.indexOf('/');
+  if (slashIndex === -1) {
+    return { llmService: '', modelId: model };
+  }
+  return {
+    llmService: model.substring(0, slashIndex),
+    modelId: model.substring(slashIndex + 1),
+  };
+}
+
+// ─── ID generation ───
+
+export function generateCompletionId(): string {
+  return `chatcmpl-${crypto.randomBytes(16).toString('hex').substring(0, 29)}`;
+}
+
+// ─── OpenAI error format ───
+
+export function toOpenAIError(statusCode: number, message: string, type = 'invalid_request_error', code?: string) {
+  return {
+    error: {
+      message,
+      type,
+      param: null,
+      code: code || null,
+    },
+  };
+}
+
+// ─── OpenAI Chat Completion response (non-streaming) ───
+
+export function toOpenAIResponse(options: {
+  id: string;
+  model: string;
+  content: string;
+  finishReason?: string;
+  usage?: { prompt_tokens?: number; completion_tokens?: number; total_tokens?: number };
+  toolCalls?: OpenAIToolCall[];
+}) {
+  const {
+    id,
+    model,
+    content,
+    finishReason = options.toolCalls?.length ? 'tool_calls' : 'stop',
+    usage,
+    toolCalls,
+  } = options;
+  return {
+    id,
+    object: 'chat.completion',
+    created: Math.floor(Date.now() / 1000),
+    model,
+    system_fingerprint: null,
+    choices: [
+      {
+        index: 0,
+        message: {
+          role: 'assistant',
+          content,
+          ...(toolCalls?.length ? { tool_calls: toolCalls } : {}),
+        },
+        logprobs: null,
+        finish_reason: finishReason,
+      },
+    ],
+    usage: usage || { prompt_tokens: 0, completion_tokens: 0, total_tokens: 0 },
+  };
+}
+
+// ─── OpenAI Streaming chunk format ───
+
+export function toOpenAIStreamChunk(options: {
+  id: string;
+  model: string;
+  delta: { role?: string; content?: string; tool_calls?: OpenAIToolCallChunk[] };
+  finishReason?: string | null;
+}) {
+  const { id, model, delta, finishReason = null } = options;
+  return {
+    id,
+    object: 'chat.completion.chunk',
+    created: Math.floor(Date.now() / 1000),
+    model,
+    system_fingerprint: null,
+    choices: [
+      {
+        index: 0,
+        delta,
+        logprobs: null,
+        finish_reason: finishReason,
+      },
+    ],
+  };
+}
+
+export interface OpenAIToolCall {
+  id: string;
+  type: 'function';
+  function: { name: string; arguments: string };
+}
+
+export interface OpenAIToolCallChunk {
+  index: number;
+  id?: string;
+  type?: 'function';
+  function?: { name?: string; arguments?: string };
+}
+
+// ─── OpenAI Embeddings response ───
+
+export function toOpenAIEmbeddingsResponse(options: { model: string; embeddings: number[][]; promptTokens?: number }) {
+  const { model, embeddings, promptTokens = 0 } = options;
+  return {
+    object: 'list' as const,
+    data: embeddings.map((embedding, index) => ({
+      object: 'embedding' as const,
+      embedding,
+      index,
+    })),
+    model,
+    usage: {
+      prompt_tokens: promptTokens,
+      total_tokens: promptTokens,
+    },
+  };
+}
+
+/**
+ * Format a streaming chunk as an SSE data line.
+ */
+export function formatSSE(data: any): string {
+  return `data: ${JSON.stringify(data)}\n\n`;
+}
+
+/**
+ * Format the terminal SSE [DONE] signal.
+ */
+export function formatSSEDone(): string {
+  return `data: [DONE]\n\n`;
+}

package/src/server/utils/streaming.ts

@@ -0,0 +1,46 @@
+import type { Context } from '@nocobase/actions';
+
+export function isStreamingRequested(value: unknown) {
+  return value !== false;
+}
+
+export function createRequestAbortController(ctx: Context) {
+  const controller = new AbortController();
+  const abort = () => {
+    if (!ctx.res.writableEnded) controller.abort(new Error('Client disconnected'));
+  };
+  ctx.req.once('aborted', abort);
+  ctx.res.once('close', abort);
+  return {
+    signal: controller.signal,
+    dispose() {
+      ctx.req.off('aborted', abort);
+      ctx.res.off('close', abort);
+    },
+  };
+}
+
+export async function writeResponse(ctx: Context, data: string) {
+  if (ctx.res.writableEnded || ctx.res.destroyed) return false;
+  if (!ctx.res.write(data)) await waitForDrain(ctx);
+  return true;
+}
+
+function waitForDrain(ctx: Context) {
+  return new Promise<void>((resolve, reject) => {
+    const cleanup = () => {
+      ctx.res.off('drain', onDrain);
+      ctx.res.off('close', onClose);
+    };
+    const onDrain = () => {
+      cleanup();
+      resolve();
+    };
+    const onClose = () => {
+      cleanup();
+      reject(new Error('Client disconnected'));
+    };
+    ctx.res.once('drain', onDrain);
+    ctx.res.once('close', onClose);
+  });
+}