@yourgpt/copilot-sdk 2.1.5-alpha.5 → 2.1.5-alpha.6

package/dist/{chunk-LHLVTGIP.cjs → chunk-2QLF7XM7.cjs}

@@ -1,6 +1,6 @@
 'use strict';
 
-var chunkKGYDGK3U_cjs = require('./chunk-KGYDGK3U.cjs');
+var chunkVION33GW_cjs = require('./chunk-VION33GW.cjs');
 var chunkJGPDQDY4_cjs = require('./chunk-JGPDQDY4.cjs');
 var chunkBJYA5NDL_cjs = require('./chunk-BJYA5NDL.cjs');
 var React2 = require('react');
@@ -1485,6 +1485,8 @@ var ChatContextOptimizer = class {
 var AbstractChat = class {
   constructor(init) {
     this.lastContextUsage = null;
+    this.sessionInitPromise = null;
+    this.sessionStatus = "idle";
     // Event handlers
     this.eventHandlers = /* @__PURE__ */ new Map();
     // Current streaming state
@@ -1513,7 +1515,8 @@ var AbstractChat = class {
       body: init.body,
       threadId: init.threadId,
       debug: init.debug,
-      optimization: init.optimization
+      optimization: init.optimization,
+      yourgptConfig: init.yourgptConfig
     };
     this.state = init.state ?? new SimpleChatState();
     this.transport = init.transport ?? new HttpTransport({
@@ -1524,6 +1527,7 @@ var AbstractChat = class {
     });
     this.callbacks = init.callbacks ?? {};
     this.optimizer = new ChatContextOptimizer(init.optimization);
+    this.onCreateSession = init.onCreateSession;
     if (init.initialMessages?.length) {
       this.state.setMessages(init.initialMessages);
     }
@@ -1602,6 +1606,23 @@ var AbstractChat = class {
       }
       this.callbacks.onMessagesChange?.(this._allMessages());
       this.callbacks.onStatusChange?.("submitted");
+      const needsSession = !this.config.threadId && (!!this.config.yourgptConfig || !!this.onCreateSession);
+      if (needsSession) {
+        if (!this.sessionInitPromise) {
+          this.setSessionStatus("creating");
+          this.sessionInitPromise = (this.onCreateSession ? Promise.resolve(this.onCreateSession()) : this._defaultCreateSession()).then((id) => {
+            this.callbacks.onThreadChange?.(id);
+            this.setSessionStatus("ready");
+            return id;
+          }).catch((err) => {
+            this.setSessionStatus("error");
+            this.sessionInitPromise = null;
+            throw err;
+          });
+        }
+        this.config.threadId = await this.sessionInitPromise;
+        this.debug("sendMessage", { threadId: this.config.threadId });
+      }
       await Promise.resolve();
       await this.processRequest({ preCreatedMessageId });
       return true;
@@ -1941,6 +1962,42 @@ var AbstractChat = class {
   setContext(context) {
     this.dynamicContext = context;
   }
+  /**
+   * Switch to a different thread (or start a new one).
+   *
+   * - Pass the session/thread ID from persistence → used as-is, no session creation call.
+   * - Pass null → threadId cleared, new session created on first sendMessage.
+   *
+   * The session ID IS the thread ID: whatever is stored in persistence is passed here directly.
+   */
+  setActiveThread(id) {
+    this.config.threadId = id ?? void 0;
+    this.sessionInitPromise = null;
+    this.setSessionStatus(id ? "ready" : "idle");
+  }
+  /**
+   * Force a new session to be created on the next sendMessage.
+   * Call this when the current session has expired or credits are exhausted.
+   * After calling this, the next sendMessage will invoke onCreateSession/yourgptConfig
+   * again and onThreadChange will fire with the new session ID.
+   */
+  renewSession() {
+    this.config.threadId = void 0;
+    this.sessionInitPromise = null;
+    this.setSessionStatus("idle");
+  }
+  setSessionStatus(status) {
+    if (this.sessionStatus !== status) {
+      this.sessionStatus = status;
+      this.callbacks.onSessionStatusChange?.(status);
+    }
+  }
+  /**
+   * Get the current session creation status.
+   */
+  getSessionStatus() {
+    return this.sessionStatus;
+  }
   /**
    * Set system prompt dynamically
    * This allows updating the system prompt after initialization
@@ -1978,9 +2035,98 @@ var AbstractChat = class {
       this.transport.setBody(body);
     }
   }
+  /**
+   * Default session creation via yourgptConfig.
+   * Only called when yourgptConfig is set and no onCreateSession is provided.
+   * The returned session_uid IS the thread ID going forward.
+   */
+  async _defaultCreateSession() {
+    if (!this.config.yourgptConfig) {
+      throw new Error(
+        "[copilot-sdk] _defaultCreateSession called without yourgptConfig"
+      );
+    }
+    const {
+      apiKey,
+      widgetUid,
+      endpoint = "https://api.yourgpt.ai"
+    } = this.config.yourgptConfig;
+    const base = endpoint.replace(/\/$/, "");
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 1e4);
+    try {
+      const res = await fetch(`${base}/chatbot/v1/copilot-sdk/createSession`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "api-key": apiKey
+        },
+        body: JSON.stringify({ widget_uid: widgetUid }),
+        signal: controller.signal
+      });
+      const data = await res.json();
+      const d = data?.data ?? data;
+      const id = d?.session_uid ?? d?.id;
+      if (!id)
+        throw new Error(
+          "[copilot-sdk] createSession failed: " + JSON.stringify(data)
+        );
+      return String(id);
+    } catch (err) {
+      if (err?.name === "AbortError") {
+        throw new Error(
+          "[copilot-sdk] createSession timed out after 10s \u2014 check your endpoint/network"
+        );
+      }
+      throw err;
+    } finally {
+      clearTimeout(timeout);
+    }
+  }
   /**
    * Build the request payload
    */
+  /** Inline text-file attachments into message content for the LLM */
+  inlineTextAttachments(messages) {
+    const textMimeTypes = /* @__PURE__ */ new Set([
+      "text/csv",
+      "text/plain",
+      "text/markdown",
+      "text/x-markdown",
+      "application/json",
+      "application/csv"
+    ]);
+    const textExts = /* @__PURE__ */ new Set(["csv", "txt", "md", "json"]);
+    return messages.map((msg) => {
+      if (msg.role !== "user" || !msg.attachments?.length) return msg;
+      const textFiles = [];
+      const binaryFiles = [];
+      for (const att of msg.attachments) {
+        const ext = att.filename?.toLowerCase().split(".").pop();
+        const isText = textMimeTypes.has(att.mimeType) || ext && textExts.has(ext);
+        if (isText && att.data && !att.url) {
+          textFiles.push(att);
+        } else {
+          binaryFiles.push(att);
+        }
+      }
+      if (textFiles.length === 0) return msg;
+      const fileParts = textFiles.map((f) => {
+        const ext = f.filename?.split(".").pop()?.toLowerCase() || "txt";
+        return `
+
+--- ${f.filename || "file"} ---
+\`\`\`${ext}
+${f.data}
+\`\`\``;
+      });
+      return {
+        ...msg,
+        content: (msg.content || "") + fileParts.join(""),
+        attachments: binaryFiles.length > 0 ? binaryFiles : void 0
+      };
+    });
+  }
   buildRequest() {
     const systemPrompt = this.dynamicContext ? `${this.config.systemPrompt || ""}
 
@@ -1989,8 +2135,9 @@ ${this.dynamicContext}`.trim() : this.config.systemPrompt;
     const rawMessages = this.requestMessageTransform ? this.requestMessageTransform(
       this.state.messages
     ) : this.state.messages;
+    const processedMessages = this.inlineTextAttachments(rawMessages);
     const optimized = this.optimizer.prepare({
-      messages: rawMessages,
+      messages: processedMessages,
       tools: this.config.tools,
       systemPrompt
     });
@@ -2253,6 +2400,15 @@ ${this.dynamicContext}`.trim() : this.config.systemPrompt;
           toolCallsEmitted,
           chunkCount
         });
+        if (chunk.type === "done" && chunk.threadId) {
+          const serverThreadId = chunk.threadId;
+          if (!this.config.threadId || this.config.threadId !== serverThreadId) {
+            this.config.threadId = serverThreadId;
+            this.sessionInitPromise = null;
+            this.setSessionStatus("ready");
+            this.callbacks.onThreadChange?.(serverThreadId);
+          }
+        }
         if (chunk.type === "done" && chunk.messages?.length) {
           this.debug("processDoneMessages", {
             count: chunk.messages.length,
@@ -2414,6 +2570,12 @@ ${this.dynamicContext}`.trim() : this.config.systemPrompt;
    * Handle JSON (non-streaming) response
    */
   handleJsonResponse(response) {
+    if (response.threadId && (!this.config.threadId || this.config.threadId !== response.threadId)) {
+      this.config.threadId = response.threadId;
+      this.sessionInitPromise = null;
+      this.setSessionStatus("ready");
+      this.callbacks.onThreadChange?.(response.threadId);
+    }
     const toolCallHiddenMap = /* @__PURE__ */ new Map();
     if (response.toolCalls) {
       for (const tc of response.toolCalls) {
@@ -2478,7 +2640,7 @@ ${this.dynamicContext}`.trim() : this.config.systemPrompt;
   }
   get log() {
     if (!this._log) {
-      this._log = chunkKGYDGK3U_cjs.createLogger("streaming", () => this.config.debug ?? false);
+      this._log = chunkVION33GW_cjs.createLogger("streaming", () => this.config.debug ?? false);
     }
     return this._log;
   }
@@ -3337,6 +3499,8 @@ var ChatWithTools = class {
       body: config.body,
       optimization: config.optimization,
       threadId: config.threadId,
+      onCreateSession: config.onCreateSession,
+      yourgptConfig: config.yourgptConfig,
       debug: config.debug,
       initialMessages: config.initialMessages,
       state: config.state,
@@ -3351,6 +3515,8 @@ var ChatWithTools = class {
         onToolCalls: callbacks.onToolCalls,
         onFinish: callbacks.onFinish,
         onContextUsageChange: callbacks.onContextUsageChange,
+        onThreadChange: callbacks.onThreadChange,
+        onSessionStatusChange: callbacks.onSessionStatusChange,
         // Server-side tool callbacks - track in agentLoop for UI display
         // IMPORTANT: Only track tools that are NOT registered client-side
         // Client-side tools are tracked via executeToolCalls() path
@@ -3590,6 +3756,26 @@ var ChatWithTools = class {
   setContext(context) {
     this.chat.setContext(context);
   }
+  /**
+   * Switch to a different thread (or start a new one).
+   * Pass the session/thread ID from persistence to reuse it, or null to start fresh.
+   */
+  setActiveThread(id) {
+    this.chat.setActiveThread(id);
+  }
+  /**
+   * Force a new session on the next sendMessage.
+   * Call this when the current session has expired or credits are exhausted.
+   */
+  renewSession() {
+    this.chat.renewSession();
+  }
+  /**
+   * Current session creation status.
+   */
+  getSessionStatus() {
+    return this.chat.getSessionStatus();
+  }
   /**
    * Set system prompt dynamically
    */
@@ -3702,7 +3888,7 @@ var ChatWithTools = class {
   // Private
   // ============================================
   debug(message, ...args) {
-    chunkKGYDGK3U_cjs.createLogger("tools", () => this.config.debug ?? false)(
+    chunkVION33GW_cjs.createLogger("tools", () => this.config.debug ?? false)(
       message,
       args.length === 1 ? args[0] : args.length > 1 ? args : void 0
     );
@@ -4461,9 +4647,6 @@ ${lines}` : lines;
 }
 
 // src/react/message-history/session-persistence.ts
-var IDB_DB_NAME = "copilot-sdk";
-var IDB_STORE = "sessions";
-var IDB_VERSION = 1;
 function saveCompactionState(storageKey, state) {
   try {
     localStorage.setItem(
@@ -4490,64 +4673,34 @@ function clearCompactionState(storageKey) {
   } catch {
   }
 }
-function openDB() {
-  return new Promise((resolve, reject) => {
-    const req = indexedDB.open(IDB_DB_NAME, IDB_VERSION);
-    req.onupgradeneeded = () => {
-      req.result.createObjectStore(IDB_STORE, { keyPath: "sessionId" });
-    };
-    req.onsuccess = () => resolve(req.result);
-    req.onerror = () => reject(req.error);
-  });
-}
-async function saveDisplayMessages(storageKey, messages) {
+function saveDisplayMessages(storageKey, messages) {
   try {
-    const db = await openDB();
-    const tx = db.transaction(IDB_STORE, "readwrite");
-    tx.objectStore(IDB_STORE).put({
-      sessionId: storageKey,
-      messages,
-      savedAt: Date.now()
-    });
-    await new Promise((res, rej) => {
-      tx.oncomplete = () => res();
-      tx.onerror = () => rej(tx.error);
-    });
-    db.close();
+    localStorage.setItem(
+      `${storageKey}-messages`,
+      JSON.stringify({ messages, savedAt: Date.now() })
+    );
   } catch {
   }
 }
-async function loadDisplayMessages(storageKey) {
+function loadDisplayMessages(storageKey) {
   try {
-    const db = await openDB();
-    const tx = db.transaction(IDB_STORE, "readonly");
-    const req = tx.objectStore(IDB_STORE).get(storageKey);
-    const result = await new Promise((res, rej) => {
-      req.onsuccess = () => res(req.result);
-      req.onerror = () => rej(req.error);
-    });
-    db.close();
-    return result?.messages ?? null;
+    const raw = localStorage.getItem(`${storageKey}-messages`);
+    if (!raw) return null;
+    const parsed = JSON.parse(raw);
+    return parsed?.messages ?? null;
   } catch {
     return null;
   }
 }
-async function clearDisplayMessages(storageKey) {
+function clearDisplayMessages(storageKey) {
   try {
-    const db = await openDB();
-    const tx = db.transaction(IDB_STORE, "readwrite");
-    tx.objectStore(IDB_STORE).delete(storageKey);
-    await new Promise((res, rej) => {
-      tx.oncomplete = () => res();
-      tx.onerror = () => rej(tx.error);
-    });
-    db.close();
+    localStorage.removeItem(`${storageKey}-messages`);
   } catch {
   }
 }
-async function clearSession(storageKey) {
+function clearSession(storageKey) {
   clearCompactionState(storageKey);
-  await clearDisplayMessages(storageKey);
+  clearDisplayMessages(storageKey);
 }
 
 // src/react/message-history/useMessageHistory.ts
@@ -4590,9 +4743,8 @@ function useMessageHistory(options = {}) {
   React2.useEffect(() => {
     if (!config.persistSession || restoredRef.current) return;
     restoredRef.current = true;
-    loadDisplayMessages(storageKey).then((saved) => {
-      if (saved?.length && messages.length === 0) ;
-    });
+    const saved = loadDisplayMessages(storageKey);
+    if (saved?.length && messages.length === 0) ;
   }, [config.persistSession, storageKey, messages.length]);
   React2.useEffect(() => {
     if (!config.persistSession || displayMessages.length === 0) return;
@@ -4746,10 +4898,10 @@ function useMessageHistory(options = {}) {
   const clearWorkingMemory = React2.useCallback(() => {
     setCompactionState((prev) => ({ ...prev, workingMemory: [] }));
   }, []);
-  const resetSession = React2.useCallback(async () => {
+  const resetSession = React2.useCallback(() => {
     setCompactionState(DEFAULT_COMPACTION_STATE);
     if (config.persistSession) {
-      await clearSession(storageKey);
+      clearSession(storageKey);
     }
   }, [config.persistSession, storageKey]);
   return {
@@ -4851,7 +5003,7 @@ function useTool(config, dependencies = []) {
   configRef.current = config;
   const inputSchema = React2.useMemo(() => {
     if (isZodSchema(config.inputSchema)) {
-      return chunkKGYDGK3U_cjs.zodToJsonSchema(config.inputSchema);
+      return chunkVION33GW_cjs.zodToJsonSchema(config.inputSchema);
     }
     return config.inputSchema;
   }, [config.inputSchema]);
@@ -5213,26 +5365,34 @@ function useCopilot() {
   }
   return context;
 }
-function CopilotProvider({
-  children,
-  runtimeUrl,
-  systemPrompt,
-  tools: toolsConfig,
-  threadId,
-  initialMessages,
-  onMessagesChange,
-  onError,
-  streaming,
-  headers,
-  body,
-  debug = false,
-  maxIterations,
-  maxIterationsMessage,
-  mcpServers,
-  optimization,
-  messageHistory,
-  skills
-}) {
+function CopilotProvider(props) {
+  const {
+    children,
+    runtimeUrl,
+    systemPrompt,
+    tools: toolsConfig,
+    threadId,
+    onCreateSession,
+    onThreadChange,
+    yourgptConfig,
+    initialMessages,
+    onMessagesChange,
+    onError,
+    streaming,
+    headers,
+    body,
+    debug = false,
+    maxIterations,
+    maxIterationsMessage,
+    mcpServers,
+    optimization,
+    messageHistory,
+    skills
+  } = props;
+  const isThreadIdControlled = Object.prototype.hasOwnProperty.call(
+    props,
+    "threadId"
+  );
   const streamListenersRef = React2.useRef(/* @__PURE__ */ new Set());
   const subscribeToStreamEvents = React2.useCallback(
     (handler) => {
@@ -5244,7 +5404,7 @@ function CopilotProvider({
   const messageMetaStoreRef = React2.useRef(new MessageMetaStore());
   const debugLog = React2.useCallback(
     (action, data) => {
-      chunkKGYDGK3U_cjs.createLogger("provider", () => debug ?? false)(action, data);
+      chunkVION33GW_cjs.createLogger("provider", () => debug ?? false)(action, data);
     },
     [debug]
   );
@@ -5256,31 +5416,29 @@ function CopilotProvider({
     }
   }, [toolsConfig]);
   const [toolExecutions, setToolExecutions] = React2.useState([]);
+  const [sessionStatus, setSessionStatus] = React2.useState(() => threadId ? "ready" : "idle");
   const [agentIteration, setAgentIteration] = React2.useState(0);
+  const [actualThreadId, setActualThreadId] = React2.useState(
+    threadId
+  );
+  const lastControlledThreadIdRef = React2.useRef({
+    controlled: isThreadIdControlled,
+    value: threadId
+  });
   const chatRef = React2.useRef(null);
   if (chatRef.current !== null && chatRef.current.disposed) {
     chatRef.current.revive();
     debugLog("Revived disposed instance (React StrictMode)");
   }
   if (chatRef.current === null) {
-    const uiInitialMessages = initialMessages?.map(
-      (m) => ({
-        id: m.id,
-        role: m.role,
-        content: m.content ?? "",
-        createdAt: m.created_at ?? /* @__PURE__ */ new Date(),
-        attachments: m.metadata?.attachments,
-        toolCalls: m.tool_calls,
-        toolCallId: m.tool_call_id,
-        parentId: m.parent_id,
-        childrenIds: m.children_ids
-      })
-    );
+    const uiInitialMessages = initialMessages;
     chatRef.current = new ReactChatWithTools(
       {
         runtimeUrl,
         systemPrompt,
         threadId,
+        onCreateSession,
+        yourgptConfig,
         initialMessages: uiInitialMessages,
         streaming,
         headers,
@@ -5305,6 +5463,15 @@ function CopilotProvider({
         onError: (error2) => {
           if (error2) onError?.(error2);
         },
+        onThreadChange: (id) => {
+          debugLog("Thread/session ID assigned:", id);
+          setActualThreadId(id);
+          onThreadChange?.(id);
+        },
+        onSessionStatusChange: (status2) => {
+          debugLog("Session status:", status2);
+          setSessionStatus(status2);
+        },
         onStreamChunk: (chunk) => {
           if (streamListenersRef.current.size > 0) {
             for (const handler of streamListenersRef.current) {
@@ -5339,6 +5506,25 @@ function CopilotProvider({
       debugLog("URL config updated from prop");
     }
   }, [runtimeUrl, debugLog]);
+  React2.useEffect(() => {
+    const prev = lastControlledThreadIdRef.current;
+    const controlChanged = prev.controlled !== isThreadIdControlled;
+    const valueChanged = prev.value !== threadId;
+    if (!controlChanged && !valueChanged) {
+      return;
+    }
+    lastControlledThreadIdRef.current = {
+      controlled: isThreadIdControlled,
+      value: threadId
+    };
+    if (!isThreadIdControlled) {
+      return;
+    }
+    chatRef.current?.setActiveThread(threadId ?? null);
+    setActualThreadId(threadId);
+    setSessionStatus(threadId ? "ready" : "idle");
+    debugLog("Thread/session synced from prop", { threadId });
+  }, [debugLog, isThreadIdControlled, threadId]);
   const EMPTY_MESSAGES = React2.useRef([]);
   const getMessagesSnapshot = React2.useCallback(() => chatRef.current.messages, []);
   const getServerMessagesSnapshot = React2.useCallback(
@@ -5364,6 +5550,15 @@ function CopilotProvider({
   );
   const error = errorFromChat ?? null;
   const isLoading = status === "streaming" || status === "submitted";
+  const setActiveThread = React2.useCallback((id) => {
+    chatRef.current?.setActiveThread(id);
+    setActualThreadId(id ?? void 0);
+  }, []);
+  const renewSession = React2.useCallback(() => {
+    chatRef.current?.renewSession();
+    setActualThreadId(void 0);
+    setSessionStatus("idle");
+  }, []);
   const registerTool = React2.useCallback((tool) => {
     chatRef.current?.registerTool(tool);
   }, []);
@@ -5570,7 +5765,10 @@ function CopilotProvider({
       // Skills
       setInlineSkills,
       // Config
-      threadId,
+      threadId: actualThreadId,
+      setActiveThread,
+      renewSession,
+      sessionStatus,
       runtimeUrl,
       toolsConfig,
       // Headless primitives
@@ -5609,7 +5807,10 @@ function CopilotProvider({
       contextUsage,
       setSystemPrompt,
       setInlineSkills,
-      threadId,
+      actualThreadId,
+      setActiveThread,
+      renewSession,
+      sessionStatus,
       runtimeUrl,
       toolsConfig
     ]
@@ -5741,5 +5942,5 @@ exports.useMessageHistoryContext = useMessageHistoryContext;
 exports.useSkillContext = useSkillContext;
 exports.useTool = useTool;
 exports.useTools = useTools;
-//# sourceMappingURL=chunk-LHLVTGIP.cjs.map
-//# sourceMappingURL=chunk-LHLVTGIP.cjs.map
+//# sourceMappingURL=chunk-2QLF7XM7.cjs.map
+//# sourceMappingURL=chunk-2QLF7XM7.cjs.map