@scenemesh/entity-engine-aimodule 1.0.0

package/dist/index.mjs

@@ -0,0 +1,1177 @@
+import {
+  CORE_VERSION,
+  InvalidToolInputError,
+  NoSuchToolError,
+  cosineSimilarity,
+  createAICore,
+  createProviderRegistry,
+  customProvider,
+  defaultSettingsMiddleware,
+  embed,
+  embedMany,
+  generateObject,
+  generateText,
+  smoothStream,
+  streamObject,
+  streamText,
+  tool,
+  wrapLanguageModel
+} from "./chunk-PRIGZEI4.mjs";
+import {
+  EntityAIModule
+} from "./chunk-SBSZ3IPB.mjs";
+import {
+  AISDKIntegration
+} from "./chunk-X42L6MTY.mjs";
+import {
+  AIToolsIntegration
+} from "./chunk-25C2NRSD.mjs";
+import {
+  AIEmbeddingsIntegration,
+  SupportedEmbeddingModels
+} from "./chunk-TDRKKUNT.mjs";
+import {
+  AISettingsManagement,
+  BuiltinSettingsPresets
+} from "./chunk-COWPK7XN.mjs";
+import {
+  AIProviderManagement
+} from "./chunk-J323UTPE.mjs";
+import {
+  AIStructuredDataIntegration
+} from "./chunk-V2SSI3SL.mjs";
+import {
+  AICoreManager
+} from "./chunk-T5A4KAVS.mjs";
+
+// src/utils/warnings.ts
+var WarningManager = class {
+  constructor() {
+    this.warnings = [];
+    this.handler = null;
+    this.maxWarnings = 100;
+  }
+  // Maximum warnings to prevent memory leaks
+  /**
+   * Initialize warning system
+   */
+  initialize() {
+    if (typeof globalThis !== "undefined") {
+      const globalHandler = globalThis.AI_SDK_LOG_WARNINGS;
+      if (globalHandler !== void 0) {
+        this.handler = globalHandler;
+      } else {
+        this.handler = true;
+      }
+    } else {
+      this.handler = true;
+    }
+  }
+  /**
+   * Set warning handler
+   */
+  setHandler(handler) {
+    this.handler = handler;
+  }
+  /**
+   * Add warning
+   */
+  warn(type, message, details, source) {
+    const warning = {
+      type,
+      message,
+      details,
+      timestamp: Date.now(),
+      source
+    };
+    this.warnings.push(warning);
+    if (this.warnings.length > this.maxWarnings) {
+      this.warnings = this.warnings.slice(-this.maxWarnings);
+    }
+    this.processWarning(warning);
+  }
+  /**
+   * Process warning
+   */
+  processWarning(warning) {
+    if (this.handler === false) {
+      return;
+    }
+    if (typeof this.handler === "function") {
+      try {
+        this.handler([warning]);
+      } catch (error) {
+        this.defaultHandler([warning]);
+      }
+    } else {
+      this.defaultHandler([warning]);
+    }
+  }
+  /**
+   * Default warning handler
+   */
+  defaultHandler(warnings) {
+    warnings.forEach((warning) => {
+      const prefix = "AI SDK Warning:";
+      const message = `${prefix} ${warning.message}`;
+    });
+  }
+  /**
+   * Get all warnings
+   */
+  getWarnings() {
+    return [...this.warnings];
+  }
+  /**
+   * Clear warnings
+   */
+  clearWarnings() {
+    this.warnings = [];
+  }
+  /**
+   * Get warnings by type
+   */
+  getWarningsByType(type) {
+    return this.warnings.filter((w) => w.type === type);
+  }
+  /**
+   * Get warning statistics
+   */
+  getWarningStats() {
+    const stats = {};
+    this.warnings.forEach((warning) => {
+      stats[warning.type] = (stats[warning.type] || 0) + 1;
+    });
+    return stats;
+  }
+};
+var warningManager = new WarningManager();
+if (typeof globalThis !== "undefined") {
+  warningManager.initialize();
+}
+function warnUnsupportedSetting(setting, model) {
+  warningManager.warn(
+    "unsupported-setting",
+    `The "${setting}" setting is not supported${model ? ` by the ${model} model` : ""}`,
+    { setting, model },
+    "entity-engine-aiui"
+  );
+}
+function warnUnsupportedTool(toolName, model) {
+  warningManager.warn(
+    "unsupported-tool",
+    `The tool "${toolName}" is not supported${model ? ` by the ${model} model` : ""}`,
+    { toolName, model },
+    "entity-engine-aiui"
+  );
+}
+function warnDeprecatedFeature(feature, replacement) {
+  const message = `The "${feature}" feature is deprecated${replacement ? ` and will be replaced with "${replacement}"` : ""}`;
+  warningManager.warn(
+    "deprecated-feature",
+    message,
+    { feature, replacement },
+    "entity-engine-aiui"
+  );
+}
+function warnValidationError(message, details) {
+  warningManager.warn(
+    "validation-error",
+    message,
+    details,
+    "entity-engine-aiui"
+  );
+}
+function warnPerformance(message, details) {
+  warningManager.warn(
+    "performance-warning",
+    message,
+    details,
+    "entity-engine-aiui"
+  );
+}
+function warn(message, details) {
+  warningManager.warn(
+    "unknown",
+    message,
+    details,
+    "entity-engine-aiui"
+  );
+}
+function setWarningHandler(handler) {
+  warningManager.setHandler(handler);
+}
+function getWarnings() {
+  return warningManager.getWarnings();
+}
+function clearWarnings() {
+  warningManager.clearWarnings();
+}
+function getWarningStats() {
+  return warningManager.getWarningStats();
+}
+if (process.env.NODE_ENV === "development") {
+  if (typeof globalThis !== "undefined") {
+    globalThis.__ENTITY_ENGINE_AIUI_WARNINGS__ = {
+      manager: warningManager,
+      getWarnings,
+      clearWarnings,
+      getWarningStats,
+      setWarningHandler
+    };
+  }
+  const originalWarn = warningManager.warn.bind(warningManager);
+  warningManager.warn = (type, message, details, source) => {
+    const stack = new Error().stack;
+    const enhancedDetails = {
+      ...details,
+      stack: stack?.split("\n").slice(2, 5).join("\n")
+      // Keep only first 3 stack levels
+    };
+    originalWarn(type, message, enhancedDetails, source);
+  };
+}
+
+// src/utils/streaming.ts
+var UIMessageStreamReader = class {
+  constructor(options) {
+    this.options = options;
+    this.reader = null;
+    this.currentMessage = null;
+    this.isReading = false;
+    this.currentMessage = options.message || null;
+  }
+  /**
+   * Start reading stream
+   */
+  async *read() {
+    if (this.isReading) {
+      throw new Error("Stream is already being read");
+    }
+    this.isReading = true;
+    this.reader = this.options.stream.getReader();
+    try {
+      let done = false;
+      while (!done) {
+        const { value, done: streamDone } = await this.reader.read();
+        done = streamDone;
+        if (value) {
+          const message = this.processChunk(value);
+          if (message) {
+            this.options.onMessage?.(message);
+            yield message;
+          }
+        }
+      }
+      if (this.currentMessage) {
+        this.options.onComplete?.(this.currentMessage);
+      }
+    } catch (error) {
+      const err = error instanceof Error ? error : new Error(String(error));
+      this.options.onError?.(err);
+      throw err;
+    } finally {
+      this.cleanup();
+    }
+  }
+  /**
+   * Process stream chunk
+   */
+  processChunk(chunk) {
+    try {
+      if (typeof chunk === "string") {
+        chunk = JSON.parse(chunk);
+      }
+      if (chunk instanceof Uint8Array) {
+        const decoder = new TextDecoder();
+        chunk = JSON.parse(decoder.decode(chunk));
+      }
+      if (chunk.type) {
+        return this.handleStreamData(chunk);
+      }
+      return null;
+    } catch (error) {
+      return null;
+    }
+  }
+  /**
+   * Handle stream data
+   */
+  handleStreamData(data) {
+    switch (data.type) {
+      case "message-start":
+        return this.handleMessageStart(data);
+      case "message-delta":
+        return this.handleMessageDelta(data);
+      case "message-stop":
+        return this.handleMessageStop(data);
+      case "text-delta":
+        return this.handleTextDelta(data);
+      case "tool-call":
+        return this.handleToolCall(data);
+      case "tool-result":
+        return this.handleToolResult(data);
+      default:
+        return null;
+    }
+  }
+  /**
+   * Handle message start
+   */
+  handleMessageStart(data) {
+    this.currentMessage = {
+      id: data.messageId || this.generateId(),
+      role: data.role || "assistant",
+      parts: [],
+      metadata: data.metadata || {},
+      ...data
+    };
+    return { ...this.currentMessage };
+  }
+  /**
+   * Handle message delta
+   */
+  handleMessageDelta(data) {
+    if (!this.currentMessage) {
+      return null;
+    }
+    if (data.content) {
+      let textPart = this.currentMessage.parts.find((p) => p.type === "text");
+      if (!textPart) {
+        textPart = { type: "text", text: "" };
+        this.currentMessage.parts.push(textPart);
+      }
+      textPart.text += data.content;
+    }
+    return { ...this.currentMessage };
+  }
+  /**
+   * Handle message stop
+   */
+  handleMessageStop(data) {
+    if (!this.currentMessage) {
+      return null;
+    }
+    if (data.finishReason) {
+      this.currentMessage.metadata = {
+        ...this.currentMessage.metadata || {},
+        finishReason: data.finishReason
+      };
+    }
+    return { ...this.currentMessage };
+  }
+  /**
+   * Handle text delta
+   */
+  handleTextDelta(data) {
+    if (!this.currentMessage) {
+      this.currentMessage = {
+        id: this.generateId(),
+        role: "assistant",
+        parts: [{ type: "text", text: data.text || "" }]
+      };
+    } else {
+      let textPart = this.currentMessage.parts.find((p) => p.type === "text");
+      if (!textPart) {
+        textPart = { type: "text", text: "" };
+        this.currentMessage.parts.push(textPart);
+      }
+      textPart.text += data.text || "";
+    }
+    return { ...this.currentMessage };
+  }
+  /**
+   * Handle tool call
+   */
+  handleToolCall(data) {
+    if (!this.currentMessage) {
+      this.currentMessage = {
+        id: this.generateId(),
+        role: "assistant",
+        parts: []
+      };
+    }
+    const toolPart = {
+      type: "dynamic-tool",
+      toolCallId: data.toolCallId,
+      toolName: data.toolName,
+      input: data.input,
+      state: "input-available"
+    };
+    this.currentMessage.parts.push(toolPart);
+    return { ...this.currentMessage };
+  }
+  /**
+   * Handle tool result
+   */
+  handleToolResult(data) {
+    if (!this.currentMessage) {
+      return null;
+    }
+    const toolPart = this.currentMessage.parts.find(
+      (p) => p.type.startsWith("tool-") && p.toolCallId === data.toolCallId
+    );
+    if (toolPart) {
+      toolPart.output = data.result;
+      toolPart.state = data.error ? "output-error" : "output-available";
+      if (data.error) {
+        toolPart.errorText = data.error;
+      }
+    }
+    return { ...this.currentMessage };
+  }
+  /**
+   * Generate ID
+   */
+  generateId() {
+    return Math.random().toString(36).substr(2, 9);
+  }
+  /**
+   * Stop reading
+   */
+  async stop() {
+    if (this.reader) {
+      await this.reader.cancel();
+    }
+    this.cleanup();
+  }
+  /**
+   * Cleanup resources
+   */
+  cleanup() {
+    this.isReading = false;
+    if (this.reader) {
+      this.reader.releaseLock();
+      this.reader = null;
+    }
+  }
+};
+async function* readUIMessageStream(options) {
+  const reader = new UIMessageStreamReader(options);
+  yield* reader.read();
+}
+async function resumeStream({
+  chatId,
+  messageId,
+  endpoint = "/api/chat/resume",
+  headers = {}
+}) {
+  const response = await fetch(endpoint, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      ...headers
+    },
+    body: JSON.stringify({
+      chatId,
+      messageId
+    })
+  });
+  if (!response.ok) {
+    throw new Error(`Resume request failed: ${response.status}`);
+  }
+  if (!response.body) {
+    throw new Error("No response body received");
+  }
+  return response.body;
+}
+var StreamStateManager = class {
+  constructor() {
+    this.state = "idle";
+    this.listeners = /* @__PURE__ */ new Set();
+    this.abortController = null;
+  }
+  /**
+   * Get current state
+   */
+  getState() {
+    return this.state;
+  }
+  /**
+   * Set state
+   */
+  setState(newState) {
+    if (this.state !== newState) {
+      this.state = newState;
+      this.notifyListeners();
+    }
+  }
+  /**
+   * Listen to state changes
+   */
+  onStateChange(listener) {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+  /**
+   * Start stream
+   */
+  startStream() {
+    this.abortController = new AbortController();
+    this.setState("connecting");
+    return this.abortController;
+  }
+  /**
+   * Abort stream
+   */
+  abortStream() {
+    if (this.abortController) {
+      this.abortController.abort();
+      this.abortController = null;
+    }
+    this.setState("aborted");
+  }
+  /**
+   * Complete stream
+   */
+  completeStream() {
+    this.abortController = null;
+    this.setState("complete");
+  }
+  /**
+   * Stream error
+   */
+  errorStream() {
+    this.abortController = null;
+    this.setState("error");
+  }
+  /**
+   * Reset state
+   */
+  reset() {
+    this.abortController = null;
+    this.setState("idle");
+  }
+  /**
+   * Notify listeners
+   */
+  notifyListeners() {
+    this.listeners.forEach((listener) => {
+      try {
+        listener(this.state);
+      } catch (error) {
+      }
+    });
+  }
+  /**
+   * Dispose
+   */
+  dispose() {
+    this.abortController = null;
+    this.listeners.clear();
+    this.setState("idle");
+  }
+};
+
+// src/utils/persistence.ts
+function createIdGenerator(options = {}) {
+  const { prefix = "", size = 12 } = options;
+  return () => {
+    const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+    let result = "";
+    for (let i = 0; i < size; i++) {
+      result += chars.charAt(Math.floor(Math.random() * chars.length));
+    }
+    return prefix ? `${prefix}-${result}` : result;
+  };
+}
+function generateId() {
+  return createIdGenerator()();
+}
+async function validateUIMessages({
+  messages,
+  tools,
+  dataPartsSchema,
+  metadataSchema
+}) {
+  const validatedMessages = [];
+  for (const message of messages) {
+    try {
+      const validatedMessage = await validateSingleMessage(message, {
+        tools,
+        dataPartsSchema,
+        metadataSchema
+      });
+      validatedMessages.push(validatedMessage);
+    } catch (error) {
+      validatedMessages.push(sanitizeMessage(message));
+    }
+  }
+  return validatedMessages;
+}
+async function validateSingleMessage(message, options) {
+  const { tools, dataPartsSchema, metadataSchema } = options;
+  if (!message.id || !message.role || !Array.isArray(message.parts)) {
+    throw new Error("Invalid message structure");
+  }
+  const validatedParts = [];
+  for (const part of message.parts) {
+    const validatedPart = await validateMessagePart(part, tools);
+    validatedParts.push(validatedPart);
+  }
+  let validatedMetadata = message.metadata;
+  if (metadataSchema && message.metadata) {
+    try {
+      validatedMetadata = metadataSchema.parse(message.metadata);
+    } catch (error) {
+      validatedMetadata = void 0;
+    }
+  }
+  return {
+    ...message,
+    parts: validatedParts,
+    metadata: validatedMetadata
+  };
+}
+async function validateMessagePart(part, tools) {
+  if (part.type === "text") {
+    if (typeof part.text !== "string") {
+      throw new Error("Text part must have a string text property");
+    }
+    return part;
+  }
+  if (part.type === "file") {
+    if (!part.filename || !part.url) {
+      throw new Error("File part must have filename and url properties");
+    }
+    return part;
+  }
+  if (part.type.startsWith("tool-") || part.type === "dynamic-tool") {
+    const toolName = part.type === "dynamic-tool" ? part.toolName : part.type.replace("tool-", "");
+    if (tools && toolName && !tools[toolName]) {
+      console.warn(`Tool ${toolName} not found in provided tools`);
+    }
+    return part;
+  }
+  if (part.type.startsWith("data-")) {
+    if (!part.data) {
+      throw new Error("Data part must have a data property");
+    }
+    return part;
+  }
+  return part;
+}
+function sanitizeMessage(message) {
+  const sanitizedParts = message.parts.filter(
+    (part) => (
+      // 保留有效的部分类型
+      part && typeof part === "object" && part.type
+    )
+  );
+  return {
+    ...message,
+    parts: sanitizedParts.length > 0 ? sanitizedParts : [
+      { type: "text", text: "[Message content could not be validated]" }
+    ]
+  };
+}
+var TypeValidationError = class extends Error {
+  constructor(message, details) {
+    super(message);
+    this.details = details;
+    this.name = "TypeValidationError";
+  }
+};
+var InMemoryMessageStore = class {
+  constructor() {
+    this.chats = /* @__PURE__ */ new Map();
+    this.metadata = /* @__PURE__ */ new Map();
+  }
+  async createChat() {
+    const id = generateId();
+    this.chats.set(id, []);
+    this.metadata.set(id, { updatedAt: /* @__PURE__ */ new Date() });
+    return id;
+  }
+  async loadChat(id) {
+    const messages = this.chats.get(id);
+    if (!messages) {
+      throw new Error(`Chat ${id} not found`);
+    }
+    return [...messages];
+  }
+  async saveChat({ chatId, messages }) {
+    this.chats.set(chatId, [...messages]);
+    const existing = this.metadata.get(chatId) || {};
+    this.metadata.set(chatId, {
+      ...existing,
+      updatedAt: /* @__PURE__ */ new Date(),
+      title: existing.title || this.extractTitle(messages)
+    });
+  }
+  async deleteChat(id) {
+    this.chats.delete(id);
+    this.metadata.delete(id);
+  }
+  async listChats() {
+    return Array.from(this.metadata.entries()).map(([id, meta]) => ({
+      id,
+      ...meta
+    }));
+  }
+  extractTitle(messages) {
+    const firstUserMessage = messages.find((m) => m.role === "user");
+    if (firstUserMessage) {
+      const textPart = firstUserMessage.parts.find((p) => p.type === "text");
+      if (textPart?.text) {
+        return textPart.text.slice(0, 50) + (textPart.text.length > 50 ? "..." : "");
+      }
+    }
+    return "Untitled Chat";
+  }
+};
+var LocalStorageMessageStore = class {
+  constructor() {
+    this.keyPrefix = "entity-engine-aiui-chat-";
+  }
+  async createChat() {
+    const id = generateId();
+    const key = this.keyPrefix + id;
+    const chatData = {
+      id,
+      messages: [],
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    localStorage.setItem(key, JSON.stringify(chatData));
+    return id;
+  }
+  async loadChat(id) {
+    const key = this.keyPrefix + id;
+    const data = localStorage.getItem(key);
+    if (!data) {
+      throw new Error(`Chat ${id} not found`);
+    }
+    try {
+      const chatData = JSON.parse(data);
+      return chatData.messages || [];
+    } catch (error) {
+      throw new Error(`Failed to parse chat data: ${error}`);
+    }
+  }
+  async saveChat({ chatId, messages }) {
+    const key = this.keyPrefix + chatId;
+    const existing = localStorage.getItem(key);
+    const chatData = {
+      id: chatId,
+      messages,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    if (existing) {
+      try {
+        const parsedExisting = JSON.parse(existing);
+        chatData.createdAt = parsedExisting.createdAt || chatData.createdAt;
+      } catch {
+      }
+    }
+    localStorage.setItem(key, JSON.stringify(chatData));
+  }
+  async deleteChat(id) {
+    const key = this.keyPrefix + id;
+    localStorage.removeItem(key);
+  }
+  async listChats() {
+    const chats = [];
+    for (let i = 0; i < localStorage.length; i++) {
+      const key = localStorage.key(i);
+      if (key?.startsWith(this.keyPrefix)) {
+        try {
+          const data = localStorage.getItem(key);
+          if (data) {
+            const chatData = JSON.parse(data);
+            chats.push({
+              id: chatData.id,
+              title: this.extractTitle(chatData.messages || []),
+              updatedAt: new Date(chatData.updatedAt || chatData.createdAt)
+            });
+          }
+        } catch {
+        }
+      }
+    }
+    return chats.sort((a, b) => b.updatedAt.getTime() - a.updatedAt.getTime());
+  }
+  extractTitle(messages) {
+    const firstUserMessage = messages.find((m) => m.role === "user");
+    if (firstUserMessage) {
+      const textPart = firstUserMessage.parts.find((p) => p.type === "text");
+      if (textPart?.text) {
+        return textPart.text.slice(0, 50) + (textPart.text.length > 50 ? "..." : "");
+      }
+    }
+    return "Untitled Chat";
+  }
+};
+
+// src/utils/index.ts
+function extractMessageText(message) {
+  return message.parts.filter((part) => part.type === "text").map((part) => part.text).join("\n");
+}
+function hasToolCalls(message) {
+  return message.parts.some(
+    (part) => part.type.startsWith("tool-") || part.type === "dynamic-tool"
+  );
+}
+function getToolCalls(message) {
+  return message.parts.filter((part) => part.type.startsWith("tool-") || part.type === "dynamic-tool").map((part) => ({
+    toolName: part.type === "dynamic-tool" ? part.toolName : part.type.replace("tool-", ""),
+    state: part.state || "unknown",
+    input: part.input,
+    output: part.output
+  }));
+}
+function hasFileAttachments(message) {
+  return message.parts.some((part) => part.type === "file");
+}
+function getFileAttachments(message) {
+  return message.parts.filter((part) => part.type === "file").map((part) => part);
+}
+function formatTimestamp(timestamp, options) {
+  if (!timestamp) return "";
+  const date = new Date(timestamp);
+  const { format = "short", includeDate = false } = options || {};
+  switch (format) {
+    case "short":
+      return date.toLocaleTimeString([], {
+        hour: "2-digit",
+        minute: "2-digit",
+        ...includeDate && {
+          month: "short",
+          day: "numeric"
+        }
+      });
+    case "long":
+      return date.toLocaleString();
+    case "relative":
+      return formatRelativeTime(timestamp);
+    default:
+      return date.toLocaleTimeString();
+  }
+}
+function formatRelativeTime(timestamp) {
+  const now = Date.now();
+  const diff = now - timestamp;
+  const minute = 60 * 1e3;
+  const hour = minute * 60;
+  const day = hour * 24;
+  const week = day * 7;
+  const month = day * 30;
+  const year = day * 365;
+  if (diff < minute) {
+    return "Just now";
+  } else if (diff < hour) {
+    const minutes = Math.floor(diff / minute);
+    return `${minutes}m ago`;
+  } else if (diff < day) {
+    const hours = Math.floor(diff / hour);
+    return `${hours}h ago`;
+  } else if (diff < week) {
+    const days = Math.floor(diff / day);
+    return `${days}d ago`;
+  } else if (diff < month) {
+    const weeks = Math.floor(diff / week);
+    return `${weeks}w ago`;
+  } else if (diff < year) {
+    const months = Math.floor(diff / month);
+    return `${months}mo ago`;
+  } else {
+    const years = Math.floor(diff / year);
+    return `${years}y ago`;
+  }
+}
+function formatFileSize(bytes) {
+  if (bytes === 0) return "0 B";
+  const k = 1024;
+  const sizes = ["B", "KB", "MB", "GB", "TB"];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return parseFloat((bytes / Math.pow(k, i)).toFixed(1)) + " " + sizes[i];
+}
+function getFileExtension(filename) {
+  return filename.split(".").pop()?.toLowerCase() || "";
+}
+function isFileTypeAccepted(file, acceptedTypes) {
+  return acceptedTypes.some((type) => {
+    if (type.endsWith("/*")) {
+      return file.type.startsWith(type.slice(0, -1));
+    }
+    return file.type === type;
+  });
+}
+function createFileUrl(file) {
+  return URL.createObjectURL(file);
+}
+function revokeFileUrl(url) {
+  URL.revokeObjectURL(url);
+}
+function truncateText(text, maxLength) {
+  if (text.length <= maxLength) return text;
+  return text.slice(0, maxLength - 3) + "...";
+}
+function highlightSearchTerms(text, searchTerms) {
+  if (!searchTerms.length) return text;
+  let highlightedText = text;
+  searchTerms.forEach((term) => {
+    const regex = new RegExp(`(${term})`, "gi");
+    highlightedText = highlightedText.replace(regex, "<mark>$1</mark>");
+  });
+  return highlightedText;
+}
+function camelToSpaced(str) {
+  return str.replace(/([A-Z])/g, " $1").trim();
+}
+function isValidUrl(string) {
+  try {
+    new URL(string);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function isValidJson(string) {
+  try {
+    JSON.parse(string);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function safeJsonParse(string, fallback) {
+  try {
+    return JSON.parse(string);
+  } catch {
+    return fallback;
+  }
+}
+function cn(...classes) {
+  return classes.filter(Boolean).join(" ");
+}
+async function safeAsync(fn, fallback) {
+  try {
+    const data = await fn();
+    return { data };
+  } catch (error) {
+    return {
+      error: error instanceof Error ? error : new Error(String(error)),
+      ...fallback !== void 0 && { data: fallback }
+    };
+  }
+}
+function createErrorMessage(error) {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  if (typeof error === "string") {
+    return error;
+  }
+  return "An unknown error occurred";
+}
+function debounce(func, delay) {
+  let timeoutId;
+  return function debouncedFunction(...args) {
+    clearTimeout(timeoutId);
+    timeoutId = setTimeout(() => func.apply(this, args), delay);
+  };
+}
+function throttle(func, delay) {
+  let inThrottle;
+  return function throttledFunction(...args) {
+    if (!inThrottle) {
+      func.apply(this, args);
+      inThrottle = true;
+      setTimeout(() => inThrottle = false, delay);
+    }
+  };
+}
+var storage = {
+  get(key, fallback) {
+    if (typeof window === "undefined") return fallback || null;
+    try {
+      const item = localStorage.getItem(key);
+      return item ? JSON.parse(item) : fallback || null;
+    } catch {
+      return fallback || null;
+    }
+  },
+  set(key, value) {
+    if (typeof window === "undefined") return false;
+    try {
+      localStorage.setItem(key, JSON.stringify(value));
+      return true;
+    } catch {
+      return false;
+    }
+  },
+  remove(key) {
+    if (typeof window === "undefined") return false;
+    try {
+      localStorage.removeItem(key);
+      return true;
+    } catch {
+      return false;
+    }
+  },
+  clear() {
+    if (typeof window === "undefined") return false;
+    try {
+      localStorage.clear();
+      return true;
+    } catch {
+      return false;
+    }
+  }
+};
+
+// src/types/index.ts
+var aimoduleError = class extends Error {
+  constructor(message, code, details) {
+    super(message);
+    this.code = code;
+    this.details = details;
+    this.name = "aimoduleError";
+  }
+};
+var aimoduleRuntimeError = class extends aimoduleError {
+  constructor(message, details) {
+    super(message, "RUNTIME_ERROR", details);
+    this.name = "aimoduleRuntimeError";
+  }
+};
+
+// src/index.ts
+async function createEntityAIModule() {
+  const { EntityAIModule: EntityAIModule2 } = await import("./ai.module-TTPMTPB3.mjs");
+  return new EntityAIModule2();
+}
+var VERSION = "1.0.0";
+var PACKAGE_NAME = "@scenemesh/entity-engine-aimodule";
+var AI_SDK_COMPATIBLE_VERSION = "^5.0.10";
+async function createaimodule(config) {
+  const { createAICore: createAICore2 } = await import("./core-ANYRS6EF.mjs");
+  const core = await createAICore2({
+    providers: config?.providers,
+    settings: config?.settings,
+    enableEmbeddings: config?.enableEmbeddings,
+    enableTools: config?.enableTools
+  });
+  const api = {
+    generateText: (options) => core.aiSDK.generateText(options),
+    streamText: (options) => core.aiSDK.streamText(options),
+    generateObject: (options) => core.structuredData.generateObject(options),
+    streamObject: (options) => core.structuredData.streamObject(options)
+  };
+  return {
+    core,
+    api
+  };
+}
+async function createQuickAI(providers) {
+  return createaimodule({
+    providers,
+    enableEmbeddings: true,
+    enableTools: true
+  });
+}
+var EntityEngineAIModule = {
+  // 工厂函数
+  create: createaimodule,
+  createQuick: createQuickAI,
+  // 版本信息
+  VERSION,
+  PACKAGE_NAME,
+  AI_SDK_COMPATIBLE_VERSION,
+  // 核心类导出（用于高级使用）
+  Core: {
+    AIProviderManagement: import("./ai-provider-3PSCVEEN.mjs").then((m) => m.AIProviderManagement),
+    AISDKIntegration: import("./ai-core-LBGYFGOK.mjs").then((m) => m.AISDKIntegration),
+    AIToolsIntegration: import("./ai-tools-JAPVYQGE.mjs").then((m) => m.AIToolsIntegration),
+    AIEmbeddingsIntegration: import("./ai-embeddings-5ED5LDXX.mjs").then((m) => m.AIEmbeddingsIntegration),
+    AISettingsManagement: import("./ai-settings-DTXEAB64.mjs").then((m) => m.AISettingsManagement),
+    AIStructuredDataIntegration: import("./ai-structured-EGZ26ZS4.mjs").then((m) => m.AIStructuredDataIntegration)
+  }
+};
+export {
+  AICoreManager,
+  AIEmbeddingsIntegration,
+  AIProviderManagement,
+  AISDKIntegration,
+  AISettingsManagement,
+  AIStructuredDataIntegration,
+  AIToolsIntegration,
+  AI_SDK_COMPATIBLE_VERSION,
+  BuiltinSettingsPresets,
+  CORE_VERSION,
+  EntityAIModule,
+  EntityEngineAIModule,
+  InMemoryMessageStore,
+  InvalidToolInputError,
+  LocalStorageMessageStore,
+  NoSuchToolError,
+  PACKAGE_NAME,
+  StreamStateManager,
+  SupportedEmbeddingModels,
+  TypeValidationError,
+  UIMessageStreamReader,
+  VERSION,
+  aimoduleError,
+  aimoduleRuntimeError,
+  camelToSpaced,
+  clearWarnings,
+  cn,
+  cosineSimilarity,
+  createAICore,
+  createEntityAIModule,
+  createErrorMessage,
+  createFileUrl,
+  createIdGenerator,
+  createProviderRegistry,
+  createQuickAI,
+  createaimodule,
+  customProvider,
+  debounce,
+  defaultSettingsMiddleware,
+  embed,
+  embedMany,
+  extractMessageText,
+  formatFileSize,
+  formatRelativeTime,
+  formatTimestamp,
+  generateId,
+  generateObject,
+  generateText,
+  getFileAttachments,
+  getFileExtension,
+  getToolCalls,
+  getWarningStats,
+  getWarnings,
+  hasFileAttachments,
+  hasToolCalls,
+  highlightSearchTerms,
+  isFileTypeAccepted,
+  isValidJson,
+  isValidUrl,
+  readUIMessageStream,
+  resumeStream,
+  revokeFileUrl,
+  safeAsync,
+  safeJsonParse,
+  setWarningHandler,
+  smoothStream,
+  storage,
+  streamObject,
+  streamText,
+  throttle,
+  tool,
+  truncateText,
+  validateUIMessages,
+  warn,
+  warnDeprecatedFeature,
+  warnPerformance,
+  warnUnsupportedSetting,
+  warnUnsupportedTool,
+  warnValidationError,
+  wrapLanguageModel
+};
+//# sourceMappingURL=index.mjs.map