@nocobase/plugin-ai 2.2.0-beta.9 → 2.3.0-alpha.1

package/dist/server/llm-providers/orcarouter.js

@@ -0,0 +1,155 @@
+/**
+ * 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.
+ */
+
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var orcarouter_exports = {};
+__export(orcarouter_exports, {
+  OrcaRouterProvider: () => OrcaRouterProvider,
+  orcarouterProviderOptions: () => orcarouterProviderOptions
+});
+module.exports = __toCommonJS(orcarouter_exports);
+var import_provider = require("./provider");
+var import_ai_manager = require("../manager/ai-manager");
+var import_lodash = __toESM(require("lodash"));
+var import_openai = require("@langchain/openai");
+var import_messages = require("@langchain/core/messages");
+var import_reasoning = require("./common/reasoning");
+class OrcaRouterProvider extends import_provider.LLMProvider {
+  get baseURL() {
+    return "https://api.orcarouter.ai/v1";
+  }
+  createModel() {
+    const { apiKey, httpReferer, xTitle } = this.serviceOptions || {};
+    const { responseFormat, structuredOutput } = this.modelOptions || {};
+    const { name, schema } = structuredOutput || {};
+    const responseFormatOptions = {
+      type: responseFormat ?? "text"
+    };
+    if (responseFormat === "json_schema" && schema) {
+      responseFormatOptions["json_schema"] = { schema, name: name ?? "schema" };
+    }
+    const defaultHeaders = {};
+    if (httpReferer) {
+      defaultHeaders["HTTP-Referer"] = httpReferer;
+    }
+    if (xTitle) {
+      defaultHeaders["X-Title"] = xTitle;
+    }
+    return new ChatOrcaRouterCompletions({
+      apiKey,
+      ...this.modelOptions,
+      modelKwargs: {
+        response_format: responseFormatOptions
+      },
+      configuration: {
+        baseURL: this.getResolvedBaseURL(),
+        ...Object.keys(defaultHeaders).length ? { defaultHeaders } : {}
+      }
+    });
+  }
+  isApiSupportedAttachment(attachment) {
+    const media = ["image/"];
+    return media.some((it) => {
+      var _a;
+      return (_a = attachment == null ? void 0 : attachment.mimetype) == null ? void 0 : _a.startsWith(it);
+    });
+  }
+  parseResponseMessage(message) {
+    var _a;
+    const result = super.parseResponseMessage(message);
+    if (["user", "tool"].includes(result == null ? void 0 : result.role)) {
+      return result;
+    }
+    const { metadata } = (message == null ? void 0 : message.toJSON()) ?? {};
+    if (!import_lodash.default.isEmpty((_a = metadata == null ? void 0 : metadata.additional_kwargs) == null ? void 0 : _a.reasoning_content)) {
+      result.content = {
+        ...result.content ?? {},
+        reasoning: {
+          status: "stop",
+          content: metadata == null ? void 0 : metadata.additional_kwargs.reasoning_content
+        }
+      };
+    }
+    return result;
+  }
+  parseReasoningContent(chunk) {
+    var _a;
+    if (!import_lodash.default.isEmpty((_a = chunk == null ? void 0 : chunk.additional_kwargs) == null ? void 0 : _a.reasoning_content)) {
+      return {
+        status: "streaming",
+        content: chunk.additional_kwargs.reasoning_content
+      };
+    }
+    return null;
+  }
+}
+class ChatOrcaRouterCompletions extends import_reasoning.ReasoningChatOpenAI {
+  _convertCompletionsDeltaToBaseMessageChunk(delta, rawResponse, defaultRole) {
+    const chunk = (0, import_openai.convertCompletionsDeltaToBaseMessageChunk)({
+      delta,
+      rawResponse,
+      includeRawResponse: this.__includeRawResponse,
+      defaultRole
+    });
+    if (chunk instanceof import_messages.AIMessageChunk) {
+      if (delta.reasoning_content) {
+        chunk.additional_kwargs.reasoning_content = delta.reasoning_content;
+      }
+    }
+    return chunk;
+  }
+}
+const orcarouterProviderOptions = {
+  title: "OrcaRouter",
+  supportedModel: [import_ai_manager.SupportedModel.LLM],
+  models: {
+    [import_ai_manager.SupportedModel.LLM]: [
+      "orcarouter/auto",
+      "openai/gpt-5.5",
+      "google/gemini-3.5-flash",
+      "anthropic/claude-opus-4.8",
+      "grok/grok-4.3",
+      "deepseek/deepseek-v4-pro",
+      "minimax/minimax-m2.7",
+      "qwen/qwen3.7-max"
+    ]
+  },
+  provider: OrcaRouterProvider
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  OrcaRouterProvider,
+  orcarouterProviderOptions
+});

package/dist/server/llm-providers/provider.d.ts

@@ -8,7 +8,7 @@
  */
 import { BaseChatModel } from '@langchain/core/language_models/chat_models';
 import { Model } from '@nocobase/database';
-import { AttachmentModel } from '@nocobase/plugin-file-manager';
+import { type AttachmentModel } from '@nocobase/plugin-file-manager';
 import { Application } from '@nocobase/server';
 import { AIChatContext, AIMessageInput } from '../types/ai-chat-conversation.type';
 import { EmbeddingsInterface } from '@langchain/core/embeddings';
@@ -27,6 +27,11 @@ export type LLMProviderInvokeOptions = {
     modelRequestParams?: Record<string, any>;
     [key: string]: any;
 };
+export type ReasoningMode = 'default' | 'off' | 'minimal' | 'low' | 'medium' | 'high' | 'xhigh';
+export type ReasoningOptions = {
+    mode: ReasoningMode;
+};
+export type ResolvedReasoningOptions = Pick<LLMProviderInvokeOptions, 'modelKwargs' | 'modelRequestParams'>;
 export type LLMModelRequestBuilderResult = {
     context: AIChatContext;
     options?: LLMProviderInvokeOptions;
@@ -45,10 +50,12 @@ export declare abstract class LLMProvider {
     serviceOptions: Record<string, any>;
     modelOptions: Record<string, any> | undefined;
     chatModel: any;
+    protected modelReasoningOptions: ReasoningOptions | undefined;
     abstract createModel(): BaseChatModel | any;
     get baseURL(): string | null;
     constructor(opts: LLMProviderOptions);
     protected getModelRequestBuilder(_model?: string): LLMModelRequestBuilder | null;
+    protected resolveReasoningOptions(_reasoning?: ReasoningOptions): ResolvedReasoningOptions;
     prepareChain(context: AIChatContext): any;
     invoke(context: AIChatContext, options?: LLMProviderInvokeOptions): Promise<any>;
     stream(context: AIChatContext, options?: any): Promise<any>;
@@ -69,7 +76,8 @@ export declare abstract class LLMProvider {
     parseAttachment(ctx: Context, attachment: AttachmentModel): Promise<ParsedAttachmentResult>;
     protected isApiSupportedAttachment(attachment: AttachmentModel): boolean;
     protected isDocumentLoaderSupportedAttachment(attachment: AttachmentModel): boolean;
-    protected convertToContent(ctx: Context, attachment: any): Promise<ParsedAttachmentResult>;
+    protected encodeAttachment(ctx: Context, attachment: AttachmentModel): Promise<string>;
+    protected convertToContent(ctx: Context, attachment: AttachmentModel): Promise<ParsedAttachmentResult>;
     protected loadDocument(ctx: Context, attachment: any): Promise<any>;
     getStructuredOutputOptions(structuredOutput: AIChatContext['structuredOutput']): any;
     testFlight(): Promise<{

package/dist/server/llm-providers/provider.js

@@ -84,6 +84,7 @@ class LLMProvider {
   serviceOptions;
   modelOptions;
   chatModel;
+  modelReasoningOptions;
   get baseURL() {
     return null;
   }
@@ -92,13 +93,18 @@ class LLMProvider {
     this.app = app;
     this.serviceOptions = resolveServiceOptions(serviceOptions, app);
     if (modelOptions) {
-      this.modelOptions = modelOptions;
+      const { _reasoning, ...restModelOptions } = modelOptions;
+      this.modelReasoningOptions = _reasoning;
+      this.modelOptions = restModelOptions;
       this.chatModel = this.createModel();
     }
   }
   getModelRequestBuilder(_model) {
     return null;
   }
+  resolveReasoningOptions(_reasoning) {
+    return {};
+  }
   prepareChain(context) {
     var _a, _b, _c, _d;
     let chain = this.chatModel;
@@ -183,6 +189,15 @@ class LLMProvider {
     return (0, import_utils2.stripToolCallTags)(chunk);
   }
   async parseAttachment(ctx, attachment) {
+    var _a;
+    const dataSourceKey = (_a = attachment == null ? void 0 : attachment.source) == null ? void 0 : _a.dataSourceKey;
+    const isExternalAttachment = Boolean(dataSourceKey && dataSourceKey !== "main");
+    if (!(attachment == null ? void 0 : attachment.storageId) && !isExternalAttachment || !(attachment == null ? void 0 : attachment.filename)) {
+      return {
+        placement: "system",
+        content: "The user provided an attachment, but it is unavailable or invalid and cannot be parsed. Do not use this attachment as evidence; tell the user the attachment is unavailable."
+      };
+    }
     if (this.isApiSupportedAttachment(attachment)) {
       return await this.convertToContent(ctx, attachment);
     } else if (this.isDocumentLoaderSupportedAttachment(attachment)) {
@@ -212,10 +227,24 @@ class LLMProvider {
     const ext = import_node_path.default.extname((attachment == null ? void 0 : attachment.filename) ?? "").toLocaleLowerCase();
     return import_document_loader.SUPPORTED_DOCUMENT_EXTNAMES.includes(ext);
   }
-  async convertToContent(ctx, attachment) {
+  async encodeAttachment(ctx, attachment) {
     const fileManager = this.app.pm.get("file-manager");
-    const url = await fileManager.getFileURL(attachment);
-    const data = await (0, import_utils2.encodeFile)(ctx, decodeURIComponent(url));
+    if (typeof ctx.get !== "function") {
+      const { stream: stream2 } = await fileManager.getFileStream(attachment);
+      return await (0, import_utils2.encodeReadableStream)(stream2);
+    }
+    const { stream } = await fileManager.getFileStream(attachment, {
+      requestOptions: {
+        headers: {
+          Referer: ctx.get("referer") || "",
+          "User-Agent": ctx.get("user-agent") || ""
+        }
+      }
+    });
+    return await (0, import_utils2.encodeReadableStream)(stream);
+  }
+  async convertToContent(ctx, attachment) {
+    const data = await this.encodeAttachment(ctx, attachment);
     if (attachment.mimetype.startsWith("image/")) {
       return {
         placement: "contentBlocks",

package/dist/server/manager/ai-chat-conversation.js

@@ -40,6 +40,7 @@ __export(ai_chat_conversation_exports, {
 });
 module.exports = __toCommonJS(ai_chat_conversation_exports);
 var import_lodash = __toESM(require("lodash"));
+var import_ai_usage_events = require("./ai-usage-events");
 const createAIChatConversation = (ctx, sessionId) => {
   return new AIChatConversationImpl(ctx, sessionId);
 };
@@ -81,6 +82,7 @@ class AIChatConversationImpl {
       ),
       transaction: this.transaction
     });
+    await (0, import_ai_usage_events.recordAIUsageEventsForMessages)(this.ctx, this.sessionId, instances, this.transaction);
     return isArray ? instances : instances[0];
   }
   async removeMessages({ messageId }) {

package/dist/server/manager/ai-context-datasource-manager.js

@@ -60,6 +60,34 @@ function serializeQueryFieldValue(value) {
   }
   return value;
 }
+function getRecordFieldValue(record, field) {
+  return field.split(".").reduce((current, key) => {
+    if (current === null || current === void 0) {
+      return current;
+    }
+    if (typeof current.get === "function") {
+      return current.get(key);
+    }
+    return current[key];
+  }, record);
+}
+function getQueryFieldOptions(collection, field) {
+  const parts = field.split(".");
+  let currentCollection = collection;
+  for (const [index, part] of parts.entries()) {
+    const currentField = currentCollection == null ? void 0 : currentCollection.getField(part);
+    if (!currentField) {
+      return;
+    }
+    if (index === parts.length - 1) {
+      return currentField.options;
+    }
+    if (!currentField.isRelationField()) {
+      return;
+    }
+    currentCollection = currentField.targetCollection();
+  }
+}
 class AIContextDatasourceManager {
   constructor(plugin) {
     this.plugin = plugin;
@@ -149,17 +177,16 @@ class AIContextDatasourceManager {
         }
       });
     }
-    const { fields, filter, sort, offset, limit } = options;
-    const result = await collection.repository.find({ fields, filter, sort, offset: offset ?? 0, limit });
+    const { fields, appends, filter, sort, offset, limit } = options;
+    const result = await collection.repository.find({ fields, appends, filter, sort, offset: offset ?? 0, limit });
     const total = await collection.repository.count({ fields, filter });
     const records = result.map(
       (x) => fields.map((field) => {
-        var _a2;
-        const { name, type } = ((_a2 = collection.getField(field)) == null ? void 0 : _a2.options) || {};
-        const value = serializeQueryFieldValue(x[field]);
+        const { name, type } = getQueryFieldOptions(collection, field) || {};
+        const value = serializeQueryFieldValue(getRecordFieldValue(x, field));
         return {
-          name,
-          type,
+          name: field.includes(".") ? field : name || field,
+          type: type || "unknown",
           value
         };
       })

package/dist/server/manager/ai-manager.d.ts

@@ -6,7 +6,7 @@
  * 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 { LLMProvider, LLMProviderOptions, EmbeddingProvider, EmbeddingProviderOptions } from '../llm-providers/provider';
+import { LLMProvider, LLMProviderOptions, EmbeddingProvider, EmbeddingProviderOptions, ReasoningOptions } from '../llm-providers/provider';
 import PluginAIServer from '../plugin';
 import { ToolManager } from './tool-manager';
 export type LLMProviderMeta = {
@@ -25,6 +25,7 @@ export type LLMModelOptions = {
     llmService: string;
     model: string;
     webSearch?: boolean;
+    reasoning?: ReasoningOptions;
 };
 export type EnabledLLMModel = {
     label: string;

package/dist/server/manager/ai-manager.js

@@ -123,7 +123,7 @@ class AIManager {
     return (0, import_recommended_models.getRecommendedModels)(provider);
   }
   async getLLMService(options) {
-    const { llmService, model, webSearch } = options ?? {};
+    const { llmService, model, webSearch, reasoning } = options ?? {};
     if (!llmService || !model) {
       throw new Error("LLM service not configured");
     }
@@ -134,6 +134,9 @@ class AIManager {
     if (webSearch === true) {
       modelOptions.builtIn = { webSearch: true };
     }
+    if (reasoning) {
+      modelOptions._reasoning = reasoning;
+    }
     const service = await this.plugin.db.getRepository("llmServices").findOne({
       filter: {
         name: llmService

package/dist/server/manager/ai-usage-events.d.ts

@@ -0,0 +1,49 @@
+/**
+ * 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 { Context } from '@nocobase/actions';
+import { Transaction } from '@nocobase/database';
+import { AIMessage } from '../types';
+type RecordLike = Record<string, unknown> & {
+    get?: (key: string) => unknown;
+};
+export type NormalizedUsageMetadata = {
+    inputTokens: number;
+    outputTokens: number;
+    totalTokens: number;
+    cachedTokens: number;
+    reasoningTokens: number;
+};
+export type AIUsageEventValues = {
+    occurredAt: Date;
+    sessionId: string;
+    messageId: string;
+    userId?: unknown;
+    aiEmployeeUsername?: unknown;
+    from: string;
+    category: string;
+    eventType: 'llm_message';
+    role: string;
+    provider: string;
+    llmService?: string;
+    model: string;
+    inputTokens: number;
+    outputTokens: number;
+    totalTokens: number;
+    cachedTokens: number;
+    reasoningTokens: number;
+    toolCallCount: number;
+    autoToolCallCount: number;
+    status: 'success';
+    rawUsageMetadata: Record<string, unknown>;
+    rawResponseMetadata?: Record<string, unknown>;
+};
+export declare function normalizeUsageMetadata(usageMetadata: Record<string, unknown>): NormalizedUsageMetadata;
+export declare function buildAIUsageEventValues(sessionId: string, message: AIMessage, conversation: RecordLike): AIUsageEventValues | null;
+export declare function recordAIUsageEventsForMessages(ctx: Context, sessionId: string, messages: AIMessage[], transaction?: Transaction): Promise<void>;
+export {};

package/dist/server/manager/ai-usage-events.js

@@ -0,0 +1,195 @@
+/**
+ * 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.
+ */
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var ai_usage_events_exports = {};
+__export(ai_usage_events_exports, {
+  buildAIUsageEventValues: () => buildAIUsageEventValues,
+  normalizeUsageMetadata: () => normalizeUsageMetadata,
+  recordAIUsageEventsForMessages: () => recordAIUsageEventsForMessages
+});
+module.exports = __toCommonJS(ai_usage_events_exports);
+const SKIPPED_MESSAGE_ROLES = /* @__PURE__ */ new Set(["user", "tool", "system"]);
+function normalizeUsageMetadata(usageMetadata) {
+  const inputTokens = getNumericValue(usageMetadata, ["input_tokens", "prompt_tokens", "inputTokens", "promptTokens"]) ?? 0;
+  const outputTokens = getNumericValue(usageMetadata, ["output_tokens", "completion_tokens", "outputTokens", "completionTokens"]) ?? 0;
+  const totalTokens = getNumericValue(usageMetadata, ["total_tokens", "totalTokens"]) ?? inputTokens + outputTokens;
+  const cachedTokens = getNumericValue(usageMetadata, ["cached_tokens", "cachedTokens"]) ?? getNestedNumericValue(usageMetadata, ["input_token_details", "cache_read"]) ?? getNestedNumericValue(usageMetadata, ["input_token_details", "cached_tokens"]) ?? getNestedNumericValue(usageMetadata, ["prompt_tokens_details", "cached_tokens"]) ?? 0;
+  const reasoningTokens = getNumericValue(usageMetadata, ["reasoning_tokens", "reasoningTokens"]) ?? getNestedNumericValue(usageMetadata, ["output_token_details", "reasoning"]) ?? getNestedNumericValue(usageMetadata, ["completion_tokens_details", "reasoning_tokens"]) ?? 0;
+  return {
+    inputTokens,
+    outputTokens,
+    totalTokens,
+    cachedTokens,
+    reasoningTokens
+  };
+}
+function buildAIUsageEventValues(sessionId, message, conversation) {
+  const role = readString(message, "role");
+  if (!role || SKIPPED_MESSAGE_ROLES.has(role)) {
+    return null;
+  }
+  const metadata = readRecord(message, "metadata");
+  const provider = readString(metadata, "provider");
+  const model = readString(metadata, "model");
+  if (!provider || !model) {
+    return null;
+  }
+  const usageMetadata = readRecord(metadata, "usage_metadata") ?? {};
+  const responseMetadata = readRecord(metadata, "response_metadata");
+  const normalizedUsage = normalizeUsageMetadata(usageMetadata);
+  const toolCalls = readArray(message, "toolCalls");
+  const autoCallTools = readArray(metadata, "autoCallTools");
+  const llmService = readString(metadata, "llmService");
+  return {
+    occurredAt: normalizeDate(readValue(message, "createdAt")),
+    sessionId,
+    messageId: String(readValue(message, "messageId") ?? ""),
+    userId: readValue(conversation, "userId"),
+    aiEmployeeUsername: readValue(conversation, "aiEmployeeUsername"),
+    from: readString(conversation, "from") ?? "main-agent",
+    category: readString(conversation, "category") ?? "chat",
+    eventType: "llm_message",
+    role,
+    provider,
+    ...llmService ? { llmService } : {},
+    model,
+    ...normalizedUsage,
+    toolCallCount: (toolCalls == null ? void 0 : toolCalls.length) ?? 0,
+    autoToolCallCount: (autoCallTools == null ? void 0 : autoCallTools.length) ?? 0,
+    status: "success",
+    rawUsageMetadata: usageMetadata,
+    ...responseMetadata ? { rawResponseMetadata: responseMetadata } : {}
+  };
+}
+async function recordAIUsageEventsForMessages(ctx, sessionId, messages, transaction) {
+  const recordableMessages = messages.filter(isRecordableLLMMessage);
+  if (recordableMessages.length === 0) {
+    return;
+  }
+  const conversation = await ctx.db.getRepository("aiConversations").findOne({
+    filter: {
+      sessionId
+    },
+    transaction
+  });
+  if (!conversation) {
+    return;
+  }
+  const usageEvents = recordableMessages.map((message) => buildAIUsageEventValues(sessionId, message, conversation)).filter(isUsageEventValues);
+  if (usageEvents.length === 0) {
+    return;
+  }
+  const usageEventsRepo = ctx.db.getRepository("aiUsageEvents");
+  for (const values of usageEvents) {
+    await usageEventsRepo.updateOrCreate({
+      filterKeys: ["messageId", "eventType"],
+      values,
+      transaction
+    });
+  }
+}
+function isUsageEventValues(value) {
+  return value !== null && value.messageId !== "";
+}
+function isRecordableLLMMessage(message) {
+  const role = readString(message, "role");
+  if (!role || SKIPPED_MESSAGE_ROLES.has(role)) {
+    return false;
+  }
+  const metadata = readRecord(message, "metadata");
+  return Boolean(readString(metadata, "provider") && readString(metadata, "model"));
+}
+function isRecord(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function readValue(source, key) {
+  if (!isRecord(source)) {
+    return void 0;
+  }
+  const value = source[key];
+  if (value !== void 0) {
+    return value;
+  }
+  if (typeof source.get === "function") {
+    return source.get(key);
+  }
+  return void 0;
+}
+function readString(source, key) {
+  const value = readValue(source, key);
+  return typeof value === "string" && value !== "" ? value : void 0;
+}
+function readRecord(source, key) {
+  const value = readValue(source, key);
+  return isRecord(value) ? value : void 0;
+}
+function readArray(source, key) {
+  const value = readValue(source, key);
+  return Array.isArray(value) ? value : void 0;
+}
+function getNumericValue(source, keys) {
+  for (const key of keys) {
+    const normalized = normalizeNumber(source[key]);
+    if (normalized !== void 0) {
+      return normalized;
+    }
+  }
+}
+function getNestedNumericValue(source, path) {
+  let current = source;
+  for (const key of path) {
+    if (!isRecord(current)) {
+      return void 0;
+    }
+    current = current[key];
+  }
+  return normalizeNumber(current);
+}
+function normalizeNumber(value) {
+  const numeric = typeof value === "number" ? value : typeof value === "string" ? Number(value) : NaN;
+  if (!Number.isFinite(numeric)) {
+    return void 0;
+  }
+  return Math.max(0, Math.trunc(numeric));
+}
+function normalizeDate(value) {
+  if (value instanceof Date && Number.isFinite(value.getTime())) {
+    return value;
+  }
+  if (typeof value === "string" || typeof value === "number") {
+    const date = new Date(value);
+    if (Number.isFinite(date.getTime())) {
+      return date;
+    }
+  }
+  return /* @__PURE__ */ new Date();
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  buildAIUsageEventValues,
+  normalizeUsageMetadata,
+  recordAIUsageEventsForMessages
+});

package/dist/server/plugin.js

@@ -75,10 +75,12 @@ var import_document_loader = require("./document-loader");
 var import_checkpoints = require("./ai-employees/checkpoints");
 var import_mimo = require("./llm-providers/mimo");
 var import_mistral = require("./llm-providers/mistral");
+var import_orcarouter = require("./llm-providers/orcarouter");
 var import_sub_agents = require("./ai-employees/sub-agents");
 var import_employee = require("./workflow/nodes/employee");
 var import_ai_knowledge_base = require("./ai-employees/ai-knowledge-base");
 var import_llm_stream_manager = require("./manager/llm-stream-manager");
+var import_attachments = require("./attachments");
 class PluginAIServer extends import_server.Plugin {
   features = new import_ai_feature_manager.AIPluginFeatureManagerImpl();
   aiManager = new import_ai_manager.AIManager(this);
@@ -186,6 +188,7 @@ class PluginAIServer extends import_server.Plugin {
     this.aiManager.registerLLMProvider("openai-completions", import_openai2.openaiCompletionsProviderOptions);
     this.aiManager.registerLLMProvider("kimi", import_kimi.kimiProviderOptions);
     this.aiManager.registerLLMProvider("xai", import_xai.xaiProviderOptions);
+    this.aiManager.registerLLMProvider("orcarouter", import_orcarouter.orcarouterProviderOptions);
   }
   registerTools() {
     const toolsManager = this.ai.toolsManager;
@@ -216,6 +219,19 @@ class PluginAIServer extends import_server.Plugin {
       },
       { before: "createMiddleware" }
     );
+    this.app.resourceManager.use(
+      async (ctx, next) => {
+        const { resourceName, actionName } = ctx.action;
+        if (resourceName === "aiFiles" && actionName === "create") {
+          (0, import_attachments.appendAIFileAttachmentSource)(ctx.action.params.values);
+        }
+        await next();
+        if (resourceName === "aiFiles" && actionName === "create") {
+          (0, import_attachments.appendAIFileAttachmentSource)(ctx.body);
+        }
+      },
+      { after: "createMiddleware" }
+    );
     Object.entries(aiEmployeeActions).forEach(([name, action]) => {
       this.app.resourceManager.registerActionHandler(`aiEmployees:${name}`, action);
     });