plugin-ai-api 1.0.7 → 1.0.9

package/src/server/usage.ts

@@ -0,0 +1,52 @@
+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 usage = response.usage;
+  const values = {
+    status,
+    httpStatus: ctx.status,
+    errorCode: response.error?.code,
+    inputTokens: usage?.prompt_tokens,
+    outputTokens: usage?.completion_tokens,
+    totalTokens: usage?.total_tokens,
+    providerRequestId: response.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

@@ -0,0 +1,71 @@
+import type { Context } from '@nocobase/actions';
+
+interface AIEmployeeModelOptions {
+  llmService: string;
+  model: string;
+}
+
+interface AIEmployeeConstructorOptions {
+  ctx: Context;
+  employee: unknown;
+  sessionId: string;
+  webSearch: boolean;
+  model: AIEmployeeModelOptions;
+  legacy: boolean;
+}
+
+interface AIEmployeeRuntime {
+  stream(options: { userMessages: unknown[] }): Promise<void>;
+  invoke(options: { userMessages: unknown[] }): Promise<unknown>;
+}
+
+export interface AgentRuntimeContext {
+  ctx: Context;
+  source: 'api';
+  employee: unknown;
+  sessionId: string;
+  userId?: number;
+  messages: Array<{ role: string; content: unknown }>;
+  metadata: Record<string, unknown>;
+}
+
+interface AgentRuntimeLifecycle {
+  runBeforeHooks(context: AgentRuntimeContext): Promise<void>;
+  runAfterHooks(
+    context: AgentRuntimeContext,
+    result: { succeeded: boolean; value?: unknown; error?: Error },
+  ): Promise<void>;
+}
+
+export function getAgentRuntimeLifecycle(ctx: Context): AgentRuntimeLifecycle | undefined {
+  return (ctx.app as typeof ctx.app & { agentRuntimeLifecycle?: AgentRuntimeLifecycle }).agentRuntimeLifecycle;
+}
+
+export type AIEmployeeConstructor = new (options: AIEmployeeConstructorOptions) => AIEmployeeRuntime;
+
+let cachedConstructor: AIEmployeeConstructor | null = null;
+
+export async function loadAIEmployeeConstructor(): Promise<AIEmployeeConstructor> {
+  if (cachedConstructor) return cachedConstructor;
+
+  const modulePath = '@nocobase/plugin-ai/dist/server/ai-employees/ai-employee.js';
+  const module = (await import(/* webpackIgnore: true */ modulePath)) as {
+    AIEmployee?: AIEmployeeConstructor;
+  };
+
+  if (typeof module.AIEmployee !== 'function') {
+    throw new Error('AIEmployee class is not exported by the installed plugin-ai runtime.');
+  }
+
+  cachedConstructor = module.AIEmployee;
+  return cachedConstructor;
+}
+
+export function createAIEmployeeOptions(
+  ctx: Context,
+  employee: unknown,
+  sessionId: string,
+  model: AIEmployeeModelOptions,
+): AIEmployeeConstructorOptions {
+  return { ctx, employee, sessionId, webSearch: false, model, legacy: false };
+}