@menuia/core 1.0.0

package/dist/index.d.mts

@@ -0,0 +1,92 @@
+interface MenuIAConfig {
+    agentId: string;
+    apiUrl?: string;
+    sessionId?: string;
+    customFields?: Record<string, string>;
+    metadata?: Record<string, unknown>;
+    channel?: 'WIDGET' | 'API';
+    onMessage?: (message: ChatMessage) => void;
+    onStatusChange?: (status: ConnectionStatus) => void;
+    onTicketCreated?: (ticketId: string) => void;
+    onError?: (error: Error) => void;
+}
+type ConnectionStatus = 'disconnected' | 'connecting' | 'connected' | 'error';
+interface ChatMessage {
+    id: string;
+    role: 'user' | 'assistant';
+    content: string;
+    createdAt: string;
+    mediaUrl?: string;
+    mediaType?: string;
+    toolCalls?: string;
+    toolResults?: string;
+    authorName?: string;
+}
+interface SendMessageOptions {
+    content: string;
+    attachments?: MessageAttachment[];
+}
+interface MessageAttachment {
+    type: 'image' | 'audio' | 'document';
+    data: string;
+    mimeType: string;
+    name?: string;
+}
+interface ChatResponse {
+    success: boolean;
+    data: {
+        conversationId: string;
+        message: string;
+        toolsUsed: string[];
+        tokensUsed: number;
+        ticketId?: string;
+    };
+}
+interface StreamEvent {
+    type: 'token' | 'tool_start' | 'tool_end' | 'done' | 'error' | 'response';
+    data: unknown;
+}
+interface WidgetSession {
+    sessionId: string;
+    conversationId?: string;
+    ticketId?: string;
+    messages: ChatMessage[];
+}
+
+declare class MenuIAClient {
+    private config;
+    private session;
+    private status;
+    private pollInterval;
+    private lastMessageCount;
+    constructor(config: MenuIAConfig);
+    /** Send a message to the AI agent */
+    sendMessage(options: SendMessageOptions): Promise<ChatResponse>;
+    /** Send a message and receive streaming response */
+    sendMessageStream(options: SendMessageOptions, onToken: (token: string, fullText: string) => void): Promise<ChatResponse | null>;
+    /** Load conversation history from server */
+    loadHistory(): Promise<ChatMessage[]>;
+    /** Start polling for new messages (human agent replies) */
+    startPolling(intervalMs?: number): void;
+    /** Stop polling */
+    stopPolling(): void;
+    /** Get current messages */
+    getMessages(): ChatMessage[];
+    /** Get connection status */
+    getStatus(): ConnectionStatus;
+    /** Get session info */
+    getSession(): WidgetSession;
+    /** Update custom fields (sent with next message) */
+    setCustomFields(fields: Record<string, string>): void;
+    /** Clear session and start fresh */
+    clearSession(): void;
+    /** Cleanup - call when component unmounts */
+    destroy(): void;
+    private setStatus;
+    private getSessionKey;
+    private loadSession;
+    private createNewSession;
+    private saveSession;
+}
+
+export { type ChatMessage, type ChatResponse, type ConnectionStatus, MenuIAClient, type MenuIAConfig, type MessageAttachment, type SendMessageOptions, type StreamEvent, type WidgetSession };

package/dist/index.d.ts

@@ -0,0 +1,92 @@
+interface MenuIAConfig {
+    agentId: string;
+    apiUrl?: string;
+    sessionId?: string;
+    customFields?: Record<string, string>;
+    metadata?: Record<string, unknown>;
+    channel?: 'WIDGET' | 'API';
+    onMessage?: (message: ChatMessage) => void;
+    onStatusChange?: (status: ConnectionStatus) => void;
+    onTicketCreated?: (ticketId: string) => void;
+    onError?: (error: Error) => void;
+}
+type ConnectionStatus = 'disconnected' | 'connecting' | 'connected' | 'error';
+interface ChatMessage {
+    id: string;
+    role: 'user' | 'assistant';
+    content: string;
+    createdAt: string;
+    mediaUrl?: string;
+    mediaType?: string;
+    toolCalls?: string;
+    toolResults?: string;
+    authorName?: string;
+}
+interface SendMessageOptions {
+    content: string;
+    attachments?: MessageAttachment[];
+}
+interface MessageAttachment {
+    type: 'image' | 'audio' | 'document';
+    data: string;
+    mimeType: string;
+    name?: string;
+}
+interface ChatResponse {
+    success: boolean;
+    data: {
+        conversationId: string;
+        message: string;
+        toolsUsed: string[];
+        tokensUsed: number;
+        ticketId?: string;
+    };
+}
+interface StreamEvent {
+    type: 'token' | 'tool_start' | 'tool_end' | 'done' | 'error' | 'response';
+    data: unknown;
+}
+interface WidgetSession {
+    sessionId: string;
+    conversationId?: string;
+    ticketId?: string;
+    messages: ChatMessage[];
+}
+
+declare class MenuIAClient {
+    private config;
+    private session;
+    private status;
+    private pollInterval;
+    private lastMessageCount;
+    constructor(config: MenuIAConfig);
+    /** Send a message to the AI agent */
+    sendMessage(options: SendMessageOptions): Promise<ChatResponse>;
+    /** Send a message and receive streaming response */
+    sendMessageStream(options: SendMessageOptions, onToken: (token: string, fullText: string) => void): Promise<ChatResponse | null>;
+    /** Load conversation history from server */
+    loadHistory(): Promise<ChatMessage[]>;
+    /** Start polling for new messages (human agent replies) */
+    startPolling(intervalMs?: number): void;
+    /** Stop polling */
+    stopPolling(): void;
+    /** Get current messages */
+    getMessages(): ChatMessage[];
+    /** Get connection status */
+    getStatus(): ConnectionStatus;
+    /** Get session info */
+    getSession(): WidgetSession;
+    /** Update custom fields (sent with next message) */
+    setCustomFields(fields: Record<string, string>): void;
+    /** Clear session and start fresh */
+    clearSession(): void;
+    /** Cleanup - call when component unmounts */
+    destroy(): void;
+    private setStatus;
+    private getSessionKey;
+    private loadSession;
+    private createNewSession;
+    private saveSession;
+}
+
+export { type ChatMessage, type ChatResponse, type ConnectionStatus, MenuIAClient, type MenuIAConfig, type MessageAttachment, type SendMessageOptions, type StreamEvent, type WidgetSession };

package/dist/index.js

@@ -0,0 +1,332 @@
+"use strict";
+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);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  MenuIAClient: () => MenuIAClient
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/client.ts
+var DEFAULT_API_URL = "https://api-ia.menuia.com/api/v1";
+var SESSION_KEY_PREFIX = "menuia_session_";
+var MenuIAClient = class {
+  constructor(config) {
+    this.status = "disconnected";
+    this.pollInterval = null;
+    this.lastMessageCount = 0;
+    this.config = {
+      ...config,
+      apiUrl: config.apiUrl || DEFAULT_API_URL,
+      channel: config.channel || "WIDGET"
+    };
+    this.session = this.loadSession();
+  }
+  // =====================
+  // PUBLIC API
+  // =====================
+  /** Send a message to the AI agent */
+  async sendMessage(options) {
+    this.setStatus("connecting");
+    try {
+      const body = {
+        agentId: this.config.agentId,
+        message: options.content,
+        channel: this.config.channel,
+        sessionId: this.session.sessionId,
+        metadata: {
+          ...this.config.metadata,
+          widgetId: this.config.agentId,
+          customData: this.config.customFields
+        }
+      };
+      if (this.session.conversationId) {
+        body.conversationId = this.session.conversationId;
+      }
+      if (options.attachments?.length) {
+        body.attachments = options.attachments;
+      }
+      const response = await fetch(`${this.config.apiUrl}/widget/message`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(body)
+      });
+      if (!response.ok) {
+        const err = await response.json().catch(() => ({}));
+        throw new Error(err.message || `HTTP ${response.status}`);
+      }
+      const data = await response.json();
+      if (data.data.conversationId) {
+        this.session.conversationId = data.data.conversationId;
+      }
+      if (data.data.ticketId) {
+        this.session.ticketId = data.data.ticketId;
+        this.config.onTicketCreated?.(data.data.ticketId);
+      }
+      const userMsg = {
+        id: `user_${Date.now()}`,
+        role: "user",
+        content: options.content,
+        createdAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      const assistantMsg = {
+        id: `assistant_${Date.now()}`,
+        role: "assistant",
+        content: data.data.message,
+        createdAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      this.session.messages.push(userMsg, assistantMsg);
+      this.saveSession();
+      this.setStatus("connected");
+      this.config.onMessage?.(assistantMsg);
+      return data;
+    } catch (error) {
+      this.setStatus("error");
+      const err = error instanceof Error ? error : new Error(String(error));
+      this.config.onError?.(err);
+      throw err;
+    }
+  }
+  /** Send a message and receive streaming response */
+  async sendMessageStream(options, onToken) {
+    this.setStatus("connecting");
+    try {
+      const body = {
+        agentId: this.config.agentId,
+        message: options.content,
+        channel: this.config.channel,
+        sessionId: this.session.sessionId,
+        metadata: {
+          ...this.config.metadata,
+          widgetId: this.config.agentId,
+          customData: this.config.customFields
+        }
+      };
+      if (this.session.conversationId) {
+        body.conversationId = this.session.conversationId;
+      }
+      if (options.attachments?.length) {
+        body.attachments = options.attachments;
+      }
+      const response = await fetch(`${this.config.apiUrl}/widget/stream`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(body)
+      });
+      if (!response.ok) {
+        const err = await response.json().catch(() => ({}));
+        throw new Error(err.message || `HTTP ${response.status}`);
+      }
+      const userMsg = {
+        id: `user_${Date.now()}`,
+        role: "user",
+        content: options.content,
+        createdAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      this.session.messages.push(userMsg);
+      this.setStatus("connected");
+      const reader = response.body?.getReader();
+      if (!reader) throw new Error("Stream not supported");
+      const decoder = new TextDecoder();
+      let fullText = "";
+      let responseData = null;
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        const chunk = decoder.decode(value, { stream: true });
+        const lines = chunk.split("\n");
+        for (const line of lines) {
+          if (!line.startsWith("data: ")) continue;
+          const jsonStr = line.slice(6).trim();
+          if (!jsonStr || jsonStr === "[DONE]") continue;
+          try {
+            const event = JSON.parse(jsonStr);
+            if (event.type === "token") {
+              const token = event.data;
+              fullText += token;
+              onToken(token, fullText);
+            } else if (event.type === "response") {
+              responseData = { success: true, data: event.data };
+              if (responseData.data.conversationId) {
+                this.session.conversationId = responseData.data.conversationId;
+              }
+              if (responseData.data.ticketId) {
+                this.session.ticketId = responseData.data.ticketId;
+                this.config.onTicketCreated?.(responseData.data.ticketId);
+              }
+            } else if (event.type === "error") {
+              const errData = event.data;
+              throw new Error(errData?.message || "Stream error");
+            }
+          } catch (e) {
+            if (e instanceof SyntaxError) continue;
+            throw e;
+          }
+        }
+      }
+      const finalContent = responseData?.data?.message || fullText;
+      const assistantMsg = {
+        id: `assistant_${Date.now()}`,
+        role: "assistant",
+        content: finalContent,
+        createdAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      this.session.messages.push(assistantMsg);
+      this.saveSession();
+      this.config.onMessage?.(assistantMsg);
+      return responseData;
+    } catch (error) {
+      this.setStatus("error");
+      const err = error instanceof Error ? error : new Error(String(error));
+      this.config.onError?.(err);
+      throw err;
+    }
+  }
+  /** Load conversation history from server */
+  async loadHistory() {
+    if (!this.session.conversationId) return [];
+    try {
+      const response = await fetch(
+        `${this.config.apiUrl}/widget/history/${this.session.sessionId}?agentId=${this.config.agentId}`
+      );
+      if (!response.ok) return this.session.messages;
+      const data = await response.json();
+      const messages = (data.messages || []).map((m) => ({
+        id: m.id,
+        role: m.role,
+        content: m.content,
+        createdAt: m.createdAt,
+        mediaUrl: m.mediaUrl,
+        mediaType: m.mediaType,
+        authorName: m.authorName
+      }));
+      this.session.messages = messages;
+      this.session.conversationId = data.conversationId || this.session.conversationId;
+      this.lastMessageCount = messages.length;
+      this.saveSession();
+      return messages;
+    } catch {
+      return this.session.messages;
+    }
+  }
+  /** Start polling for new messages (human agent replies) */
+  startPolling(intervalMs = 1e4) {
+    this.stopPolling();
+    this.pollInterval = setInterval(async () => {
+      const messages = await this.loadHistory();
+      if (messages.length > this.lastMessageCount) {
+        const newMessages = messages.slice(this.lastMessageCount);
+        for (const msg of newMessages) {
+          if (msg.role === "assistant") {
+            this.config.onMessage?.(msg);
+          }
+        }
+        this.lastMessageCount = messages.length;
+      }
+    }, intervalMs);
+  }
+  /** Stop polling */
+  stopPolling() {
+    if (this.pollInterval) {
+      clearInterval(this.pollInterval);
+      this.pollInterval = null;
+    }
+  }
+  /** Get current messages */
+  getMessages() {
+    return [...this.session.messages];
+  }
+  /** Get connection status */
+  getStatus() {
+    return this.status;
+  }
+  /** Get session info */
+  getSession() {
+    return { ...this.session };
+  }
+  /** Update custom fields (sent with next message) */
+  setCustomFields(fields) {
+    this.config.customFields = { ...this.config.customFields, ...fields };
+  }
+  /** Clear session and start fresh */
+  clearSession() {
+    this.session = this.createNewSession();
+    this.saveSession();
+    this.lastMessageCount = 0;
+  }
+  /** Cleanup - call when component unmounts */
+  destroy() {
+    this.stopPolling();
+  }
+  // =====================
+  // PRIVATE
+  // =====================
+  setStatus(status) {
+    if (this.status !== status) {
+      this.status = status;
+      this.config.onStatusChange?.(status);
+    }
+  }
+  getSessionKey() {
+    return `${SESSION_KEY_PREFIX}${this.config.agentId}`;
+  }
+  loadSession() {
+    if (this.config.sessionId) {
+      try {
+        const stored = localStorage.getItem(this.getSessionKey());
+        if (stored) {
+          const parsed = JSON.parse(stored);
+          if (parsed.sessionId === this.config.sessionId) {
+            return parsed;
+          }
+        }
+      } catch {
+      }
+      return {
+        sessionId: this.config.sessionId,
+        messages: []
+      };
+    }
+    try {
+      const stored = localStorage.getItem(this.getSessionKey());
+      if (stored) {
+        return JSON.parse(stored);
+      }
+    } catch {
+    }
+    return this.createNewSession();
+  }
+  createNewSession() {
+    return {
+      sessionId: `widget_${crypto.randomUUID?.() || Math.random().toString(36).slice(2)}`,
+      messages: []
+    };
+  }
+  saveSession() {
+    try {
+      localStorage.setItem(this.getSessionKey(), JSON.stringify(this.session));
+    } catch {
+    }
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MenuIAClient
+});

package/dist/index.mjs

@@ -0,0 +1,305 @@
+// src/client.ts
+var DEFAULT_API_URL = "https://api-ia.menuia.com/api/v1";
+var SESSION_KEY_PREFIX = "menuia_session_";
+var MenuIAClient = class {
+  constructor(config) {
+    this.status = "disconnected";
+    this.pollInterval = null;
+    this.lastMessageCount = 0;
+    this.config = {
+      ...config,
+      apiUrl: config.apiUrl || DEFAULT_API_URL,
+      channel: config.channel || "WIDGET"
+    };
+    this.session = this.loadSession();
+  }
+  // =====================
+  // PUBLIC API
+  // =====================
+  /** Send a message to the AI agent */
+  async sendMessage(options) {
+    this.setStatus("connecting");
+    try {
+      const body = {
+        agentId: this.config.agentId,
+        message: options.content,
+        channel: this.config.channel,
+        sessionId: this.session.sessionId,
+        metadata: {
+          ...this.config.metadata,
+          widgetId: this.config.agentId,
+          customData: this.config.customFields
+        }
+      };
+      if (this.session.conversationId) {
+        body.conversationId = this.session.conversationId;
+      }
+      if (options.attachments?.length) {
+        body.attachments = options.attachments;
+      }
+      const response = await fetch(`${this.config.apiUrl}/widget/message`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(body)
+      });
+      if (!response.ok) {
+        const err = await response.json().catch(() => ({}));
+        throw new Error(err.message || `HTTP ${response.status}`);
+      }
+      const data = await response.json();
+      if (data.data.conversationId) {
+        this.session.conversationId = data.data.conversationId;
+      }
+      if (data.data.ticketId) {
+        this.session.ticketId = data.data.ticketId;
+        this.config.onTicketCreated?.(data.data.ticketId);
+      }
+      const userMsg = {
+        id: `user_${Date.now()}`,
+        role: "user",
+        content: options.content,
+        createdAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      const assistantMsg = {
+        id: `assistant_${Date.now()}`,
+        role: "assistant",
+        content: data.data.message,
+        createdAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      this.session.messages.push(userMsg, assistantMsg);
+      this.saveSession();
+      this.setStatus("connected");
+      this.config.onMessage?.(assistantMsg);
+      return data;
+    } catch (error) {
+      this.setStatus("error");
+      const err = error instanceof Error ? error : new Error(String(error));
+      this.config.onError?.(err);
+      throw err;
+    }
+  }
+  /** Send a message and receive streaming response */
+  async sendMessageStream(options, onToken) {
+    this.setStatus("connecting");
+    try {
+      const body = {
+        agentId: this.config.agentId,
+        message: options.content,
+        channel: this.config.channel,
+        sessionId: this.session.sessionId,
+        metadata: {
+          ...this.config.metadata,
+          widgetId: this.config.agentId,
+          customData: this.config.customFields
+        }
+      };
+      if (this.session.conversationId) {
+        body.conversationId = this.session.conversationId;
+      }
+      if (options.attachments?.length) {
+        body.attachments = options.attachments;
+      }
+      const response = await fetch(`${this.config.apiUrl}/widget/stream`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(body)
+      });
+      if (!response.ok) {
+        const err = await response.json().catch(() => ({}));
+        throw new Error(err.message || `HTTP ${response.status}`);
+      }
+      const userMsg = {
+        id: `user_${Date.now()}`,
+        role: "user",
+        content: options.content,
+        createdAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      this.session.messages.push(userMsg);
+      this.setStatus("connected");
+      const reader = response.body?.getReader();
+      if (!reader) throw new Error("Stream not supported");
+      const decoder = new TextDecoder();
+      let fullText = "";
+      let responseData = null;
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        const chunk = decoder.decode(value, { stream: true });
+        const lines = chunk.split("\n");
+        for (const line of lines) {
+          if (!line.startsWith("data: ")) continue;
+          const jsonStr = line.slice(6).trim();
+          if (!jsonStr || jsonStr === "[DONE]") continue;
+          try {
+            const event = JSON.parse(jsonStr);
+            if (event.type === "token") {
+              const token = event.data;
+              fullText += token;
+              onToken(token, fullText);
+            } else if (event.type === "response") {
+              responseData = { success: true, data: event.data };
+              if (responseData.data.conversationId) {
+                this.session.conversationId = responseData.data.conversationId;
+              }
+              if (responseData.data.ticketId) {
+                this.session.ticketId = responseData.data.ticketId;
+                this.config.onTicketCreated?.(responseData.data.ticketId);
+              }
+            } else if (event.type === "error") {
+              const errData = event.data;
+              throw new Error(errData?.message || "Stream error");
+            }
+          } catch (e) {
+            if (e instanceof SyntaxError) continue;
+            throw e;
+          }
+        }
+      }
+      const finalContent = responseData?.data?.message || fullText;
+      const assistantMsg = {
+        id: `assistant_${Date.now()}`,
+        role: "assistant",
+        content: finalContent,
+        createdAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      this.session.messages.push(assistantMsg);
+      this.saveSession();
+      this.config.onMessage?.(assistantMsg);
+      return responseData;
+    } catch (error) {
+      this.setStatus("error");
+      const err = error instanceof Error ? error : new Error(String(error));
+      this.config.onError?.(err);
+      throw err;
+    }
+  }
+  /** Load conversation history from server */
+  async loadHistory() {
+    if (!this.session.conversationId) return [];
+    try {
+      const response = await fetch(
+        `${this.config.apiUrl}/widget/history/${this.session.sessionId}?agentId=${this.config.agentId}`
+      );
+      if (!response.ok) return this.session.messages;
+      const data = await response.json();
+      const messages = (data.messages || []).map((m) => ({
+        id: m.id,
+        role: m.role,
+        content: m.content,
+        createdAt: m.createdAt,
+        mediaUrl: m.mediaUrl,
+        mediaType: m.mediaType,
+        authorName: m.authorName
+      }));
+      this.session.messages = messages;
+      this.session.conversationId = data.conversationId || this.session.conversationId;
+      this.lastMessageCount = messages.length;
+      this.saveSession();
+      return messages;
+    } catch {
+      return this.session.messages;
+    }
+  }
+  /** Start polling for new messages (human agent replies) */
+  startPolling(intervalMs = 1e4) {
+    this.stopPolling();
+    this.pollInterval = setInterval(async () => {
+      const messages = await this.loadHistory();
+      if (messages.length > this.lastMessageCount) {
+        const newMessages = messages.slice(this.lastMessageCount);
+        for (const msg of newMessages) {
+          if (msg.role === "assistant") {
+            this.config.onMessage?.(msg);
+          }
+        }
+        this.lastMessageCount = messages.length;
+      }
+    }, intervalMs);
+  }
+  /** Stop polling */
+  stopPolling() {
+    if (this.pollInterval) {
+      clearInterval(this.pollInterval);
+      this.pollInterval = null;
+    }
+  }
+  /** Get current messages */
+  getMessages() {
+    return [...this.session.messages];
+  }
+  /** Get connection status */
+  getStatus() {
+    return this.status;
+  }
+  /** Get session info */
+  getSession() {
+    return { ...this.session };
+  }
+  /** Update custom fields (sent with next message) */
+  setCustomFields(fields) {
+    this.config.customFields = { ...this.config.customFields, ...fields };
+  }
+  /** Clear session and start fresh */
+  clearSession() {
+    this.session = this.createNewSession();
+    this.saveSession();
+    this.lastMessageCount = 0;
+  }
+  /** Cleanup - call when component unmounts */
+  destroy() {
+    this.stopPolling();
+  }
+  // =====================
+  // PRIVATE
+  // =====================
+  setStatus(status) {
+    if (this.status !== status) {
+      this.status = status;
+      this.config.onStatusChange?.(status);
+    }
+  }
+  getSessionKey() {
+    return `${SESSION_KEY_PREFIX}${this.config.agentId}`;
+  }
+  loadSession() {
+    if (this.config.sessionId) {
+      try {
+        const stored = localStorage.getItem(this.getSessionKey());
+        if (stored) {
+          const parsed = JSON.parse(stored);
+          if (parsed.sessionId === this.config.sessionId) {
+            return parsed;
+          }
+        }
+      } catch {
+      }
+      return {
+        sessionId: this.config.sessionId,
+        messages: []
+      };
+    }
+    try {
+      const stored = localStorage.getItem(this.getSessionKey());
+      if (stored) {
+        return JSON.parse(stored);
+      }
+    } catch {
+    }
+    return this.createNewSession();
+  }
+  createNewSession() {
+    return {
+      sessionId: `widget_${crypto.randomUUID?.() || Math.random().toString(36).slice(2)}`,
+      messages: []
+    };
+  }
+  saveSession() {
+    try {
+      localStorage.setItem(this.getSessionKey(), JSON.stringify(this.session));
+    } catch {
+    }
+  }
+};
+export {
+  MenuIAClient
+};

package/package.json

@@ -0,0 +1,19 @@
+{
+  "name": "@menuia/core",
+  "version": "1.0.0",
+  "description": "MenuIA Chat SDK - Core",
+  "main": "dist/index.js",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "files": ["dist"],
+  "scripts": {
+    "build": "tsup src/index.ts --format cjs,esm --dts --clean",
+    "dev": "tsup src/index.ts --format cjs,esm --dts --watch"
+  },
+  "peerDependencies": {},
+  "devDependencies": {
+    "tsup": "^8.0.0",
+    "typescript": "^5.3.0"
+  },
+  "license": "MIT"
+}