@scenemesh/entity-engine-aimodule 1.0.0

package/dist/index.js

@@ -0,0 +1,1177 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+var _chunkDZFQ6I23js = require('./chunk-DZFQ6I23.js');
+
+
+var _chunkDXQTHA75js = require('./chunk-DXQTHA75.js');
+
+
+var _chunk6IUKES2Ljs = require('./chunk-6IUKES2L.js');
+
+
+var _chunkYSVMY77Hjs = require('./chunk-YSVMY77H.js');
+
+
+
+var _chunkTJFNODPEjs = require('./chunk-TJFNODPE.js');
+
+
+
+var _chunkLHNNALVFjs = require('./chunk-LHNNALVF.js');
+
+
+var _chunkOTNOFOVWjs = require('./chunk-OTNOFOVW.js');
+
+
+var _chunk4JQ7UOXHjs = require('./chunk-4JQ7UOXH.js');
+
+
+var _chunkCTEXPMVZjs = require('./chunk-CTEXPMVZ.js');
+
+// 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: _optionalChain([stack, 'optionalAccess', _ => _.split, 'call', _2 => _2("\n"), 'access', _3 => _3.slice, 'call', _4 => _4(2, 5), 'access', _5 => _5.join, 'call', _6 => _6("\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) {
+            _optionalChain([this, 'access', _7 => _7.options, 'access', _8 => _8.onMessage, 'optionalCall', _9 => _9(message)]);
+            yield message;
+          }
+        }
+      }
+      if (this.currentMessage) {
+        _optionalChain([this, 'access', _10 => _10.options, 'access', _11 => _11.onComplete, 'optionalCall', _12 => _12(this.currentMessage)]);
+      }
+    } catch (error) {
+      const err = error instanceof Error ? error : new Error(String(error));
+      _optionalChain([this, 'access', _13 => _13.options, 'access', _14 => _14.onError, 'optionalCall', _15 => _15(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 (_optionalChain([textPart, 'optionalAccess', _16 => _16.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 (e) {
+      }
+    }
+    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 (_optionalChain([key, 'optionalAccess', _17 => _17.startsWith, 'call', _18 => _18(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 (e2) {
+        }
+      }
+    }
+    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 (_optionalChain([textPart, 'optionalAccess', _19 => _19.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 _optionalChain([filename, 'access', _20 => _20.split, 'call', _21 => _21("."), 'access', _22 => _22.pop, 'call', _23 => _23(), 'optionalAccess', _24 => _24.toLowerCase, 'call', _25 => _25()]) || "";
+}
+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 (e3) {
+    return false;
+  }
+}
+function isValidJson(string) {
+  try {
+    JSON.parse(string);
+    return true;
+  } catch (e4) {
+    return false;
+  }
+}
+function safeJsonParse(string, fallback) {
+  try {
+    return JSON.parse(string);
+  } catch (e5) {
+    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 (e6) {
+      return fallback || null;
+    }
+  },
+  set(key, value) {
+    if (typeof window === "undefined") return false;
+    try {
+      localStorage.setItem(key, JSON.stringify(value));
+      return true;
+    } catch (e7) {
+      return false;
+    }
+  },
+  remove(key) {
+    if (typeof window === "undefined") return false;
+    try {
+      localStorage.removeItem(key);
+      return true;
+    } catch (e8) {
+      return false;
+    }
+  },
+  clear() {
+    if (typeof window === "undefined") return false;
+    try {
+      localStorage.clear();
+      return true;
+    } catch (e9) {
+      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 Promise.resolve().then(() => _interopRequireWildcard(require("./ai.module-GAHVCBTP.js")));
+  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 Promise.resolve().then(() => _interopRequireWildcard(require("./core-K5K34DCS.js")));
+  const core = await createAICore2({
+    providers: _optionalChain([config, 'optionalAccess', _26 => _26.providers]),
+    settings: _optionalChain([config, 'optionalAccess', _27 => _27.settings]),
+    enableEmbeddings: _optionalChain([config, 'optionalAccess', _28 => _28.enableEmbeddings]),
+    enableTools: _optionalChain([config, 'optionalAccess', _29 => _29.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: Promise.resolve().then(() => _interopRequireWildcard(require("./ai-provider-WMPMVZFL.js"))).then((m) => m.AIProviderManagement),
+    AISDKIntegration: Promise.resolve().then(() => _interopRequireWildcard(require("./ai-core-UGJWSCQN.js"))).then((m) => m.AISDKIntegration),
+    AIToolsIntegration: Promise.resolve().then(() => _interopRequireWildcard(require("./ai-tools-B3R77HZ3.js"))).then((m) => m.AIToolsIntegration),
+    AIEmbeddingsIntegration: Promise.resolve().then(() => _interopRequireWildcard(require("./ai-embeddings-WCXZMMTZ.js"))).then((m) => m.AIEmbeddingsIntegration),
+    AISettingsManagement: Promise.resolve().then(() => _interopRequireWildcard(require("./ai-settings-DGCFPK3U.js"))).then((m) => m.AISettingsManagement),
+    AIStructuredDataIntegration: Promise.resolve().then(() => _interopRequireWildcard(require("./ai-structured-N2FZLO4A.js"))).then((m) => m.AIStructuredDataIntegration)
+  }
+};
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.AICoreManager = _chunkCTEXPMVZjs.AICoreManager; exports.AIEmbeddingsIntegration = _chunkTJFNODPEjs.AIEmbeddingsIntegration; exports.AIProviderManagement = _chunkOTNOFOVWjs.AIProviderManagement; exports.AISDKIntegration = _chunk6IUKES2Ljs.AISDKIntegration; exports.AISettingsManagement = _chunkLHNNALVFjs.AISettingsManagement; exports.AIStructuredDataIntegration = _chunk4JQ7UOXHjs.AIStructuredDataIntegration; exports.AIToolsIntegration = _chunkYSVMY77Hjs.AIToolsIntegration; exports.AI_SDK_COMPATIBLE_VERSION = AI_SDK_COMPATIBLE_VERSION; exports.BuiltinSettingsPresets = _chunkLHNNALVFjs.BuiltinSettingsPresets; exports.CORE_VERSION = _chunkDZFQ6I23js.CORE_VERSION; exports.EntityAIModule = _chunkDXQTHA75js.EntityAIModule; exports.EntityEngineAIModule = EntityEngineAIModule; exports.InMemoryMessageStore = InMemoryMessageStore; exports.InvalidToolInputError = _chunkDZFQ6I23js.InvalidToolInputError; exports.LocalStorageMessageStore = LocalStorageMessageStore; exports.NoSuchToolError = _chunkDZFQ6I23js.NoSuchToolError; exports.PACKAGE_NAME = PACKAGE_NAME; exports.StreamStateManager = StreamStateManager; exports.SupportedEmbeddingModels = _chunkTJFNODPEjs.SupportedEmbeddingModels; exports.TypeValidationError = TypeValidationError; exports.UIMessageStreamReader = UIMessageStreamReader; exports.VERSION = VERSION; exports.aimoduleError = aimoduleError; exports.aimoduleRuntimeError = aimoduleRuntimeError; exports.camelToSpaced = camelToSpaced; exports.clearWarnings = clearWarnings; exports.cn = cn; exports.cosineSimilarity = _chunkDZFQ6I23js.cosineSimilarity; exports.createAICore = _chunkDZFQ6I23js.createAICore; exports.createEntityAIModule = createEntityAIModule; exports.createErrorMessage = createErrorMessage; exports.createFileUrl = createFileUrl; exports.createIdGenerator = createIdGenerator; exports.createProviderRegistry = _chunkDZFQ6I23js.createProviderRegistry; exports.createQuickAI = createQuickAI; exports.createaimodule = createaimodule; exports.customProvider = _chunkDZFQ6I23js.customProvider; exports.debounce = debounce; exports.defaultSettingsMiddleware = _chunkDZFQ6I23js.defaultSettingsMiddleware; exports.embed = _chunkDZFQ6I23js.embed; exports.embedMany = _chunkDZFQ6I23js.embedMany; exports.extractMessageText = extractMessageText; exports.formatFileSize = formatFileSize; exports.formatRelativeTime = formatRelativeTime; exports.formatTimestamp = formatTimestamp; exports.generateId = generateId; exports.generateObject = _chunkDZFQ6I23js.generateObject; exports.generateText = _chunkDZFQ6I23js.generateText; exports.getFileAttachments = getFileAttachments; exports.getFileExtension = getFileExtension; exports.getToolCalls = getToolCalls; exports.getWarningStats = getWarningStats; exports.getWarnings = getWarnings; exports.hasFileAttachments = hasFileAttachments; exports.hasToolCalls = hasToolCalls; exports.highlightSearchTerms = highlightSearchTerms; exports.isFileTypeAccepted = isFileTypeAccepted; exports.isValidJson = isValidJson; exports.isValidUrl = isValidUrl; exports.readUIMessageStream = readUIMessageStream; exports.resumeStream = resumeStream; exports.revokeFileUrl = revokeFileUrl; exports.safeAsync = safeAsync; exports.safeJsonParse = safeJsonParse; exports.setWarningHandler = setWarningHandler; exports.smoothStream = _chunkDZFQ6I23js.smoothStream; exports.storage = storage; exports.streamObject = _chunkDZFQ6I23js.streamObject; exports.streamText = _chunkDZFQ6I23js.streamText; exports.throttle = throttle; exports.tool = _chunkDZFQ6I23js.tool; exports.truncateText = truncateText; exports.validateUIMessages = validateUIMessages; exports.warn = warn; exports.warnDeprecatedFeature = warnDeprecatedFeature; exports.warnPerformance = warnPerformance; exports.warnUnsupportedSetting = warnUnsupportedSetting; exports.warnUnsupportedTool = warnUnsupportedTool; exports.warnValidationError = warnValidationError; exports.wrapLanguageModel = _chunkDZFQ6I23js.wrapLanguageModel;
+//# sourceMappingURL=index.js.map