@copilotkitnext/core 0.0.13-alpha.0 → 0.0.13

package/dist/index.mjs

@@ -732,7 +732,9 @@ var RunHandler = class {
    * Run an agent
    */
   async runAgent({ agent, withMessages }) {
-    void this.core.suggestionEngine.clearSuggestions(agent.agentId);
+    if (agent.agentId) {
+      void this.core.suggestionEngine.clearSuggestions(agent.agentId);
+    }
     if (agent instanceof HttpAgent3) {
       agent.headers = { ...this.core.headers };
     }
@@ -1088,6 +1090,186 @@ function createToolSchema(tool) {
   return schema;
 }
 
+// src/core/state-manager.ts
+var StateManager = class {
+  constructor(core) {
+    this.core = core;
+  }
+  // State tracking: agentId -> threadId -> runId -> state
+  stateByRun = /* @__PURE__ */ new Map();
+  // Message tracking: agentId -> threadId -> messageId -> runId
+  messageToRun = /* @__PURE__ */ new Map();
+  // Agent subscriptions for cleanup
+  agentSubscriptions = /* @__PURE__ */ new Map();
+  /**
+   * Initialize state tracking for an agent
+   */
+  initialize() {
+  }
+  /**
+   * Subscribe to an agent's events to track state and messages
+   */
+  subscribeToAgent(agent) {
+    if (!agent.agentId) {
+      return;
+    }
+    const agentId = agent.agentId;
+    this.unsubscribeFromAgent(agentId);
+    const { unsubscribe } = agent.subscribe({
+      onRunStartedEvent: ({ event, state }) => {
+        this.handleRunStarted(agent, event, state);
+      },
+      onRunFinishedEvent: ({ event, state }) => {
+        this.handleRunFinished(agent, event, state);
+      },
+      onStateSnapshotEvent: ({ event, input, state }) => {
+        this.handleStateSnapshot(agent, event, input, state);
+      },
+      onStateDeltaEvent: ({ event, input, state }) => {
+        this.handleStateDelta(agent, event, input, state);
+      },
+      onMessagesSnapshotEvent: ({ event, input, messages }) => {
+        this.handleMessagesSnapshot(agent, event, input, messages);
+      },
+      onNewMessage: ({ message, input }) => {
+        this.handleNewMessage(agent, message, input);
+      }
+    });
+    this.agentSubscriptions.set(agentId, unsubscribe);
+  }
+  /**
+   * Unsubscribe from an agent's events
+   */
+  unsubscribeFromAgent(agentId) {
+    const unsubscribe = this.agentSubscriptions.get(agentId);
+    if (unsubscribe) {
+      unsubscribe();
+      this.agentSubscriptions.delete(agentId);
+    }
+  }
+  /**
+   * Get state for a specific run
+   * Returns a deep copy to prevent external mutations
+   */
+  getStateByRun(agentId, threadId, runId) {
+    const state = this.stateByRun.get(agentId)?.get(threadId)?.get(runId);
+    if (!state) return void 0;
+    return JSON.parse(JSON.stringify(state));
+  }
+  /**
+   * Get runId associated with a message
+   */
+  getRunIdForMessage(agentId, threadId, messageId) {
+    return this.messageToRun.get(agentId)?.get(threadId)?.get(messageId);
+  }
+  /**
+   * Get all states for an agent's thread
+   */
+  getStatesForThread(agentId, threadId) {
+    return this.stateByRun.get(agentId)?.get(threadId) ?? /* @__PURE__ */ new Map();
+  }
+  /**
+   * Get all run IDs for an agent's thread
+   */
+  getRunIdsForThread(agentId, threadId) {
+    const threadStates = this.stateByRun.get(agentId)?.get(threadId);
+    return threadStates ? Array.from(threadStates.keys()) : [];
+  }
+  /**
+   * Handle run started event
+   */
+  handleRunStarted(agent, event, state) {
+    if (!agent.agentId) return;
+    const { threadId, runId } = event;
+    this.saveState(agent.agentId, threadId, runId, state);
+  }
+  /**
+   * Handle run finished event
+   */
+  handleRunFinished(agent, event, state) {
+    if (!agent.agentId) return;
+    const { threadId, runId } = event;
+    this.saveState(agent.agentId, threadId, runId, state);
+  }
+  /**
+   * Handle state snapshot event
+   */
+  handleStateSnapshot(agent, event, input, state) {
+    if (!agent.agentId) return;
+    const { threadId, runId } = input;
+    const mergedState = { ...state, ...event.snapshot };
+    this.saveState(agent.agentId, threadId, runId, mergedState);
+  }
+  /**
+   * Handle state delta event
+   */
+  handleStateDelta(agent, event, input, state) {
+    if (!agent.agentId) return;
+    const { threadId, runId } = input;
+    this.saveState(agent.agentId, threadId, runId, state);
+  }
+  /**
+   * Handle messages snapshot event
+   */
+  handleMessagesSnapshot(agent, event, input, messages) {
+    if (!agent.agentId) return;
+    const { threadId, runId } = input;
+    for (const message of event.messages) {
+      this.associateMessageWithRun(agent.agentId, threadId, message.id, runId);
+    }
+  }
+  /**
+   * Handle new message event
+   */
+  handleNewMessage(agent, message, input) {
+    if (!agent.agentId || !input) return;
+    const { threadId, runId } = input;
+    this.associateMessageWithRun(agent.agentId, threadId, message.id, runId);
+  }
+  /**
+   * Save state for a specific run
+   */
+  saveState(agentId, threadId, runId, state) {
+    if (!this.stateByRun.has(agentId)) {
+      this.stateByRun.set(agentId, /* @__PURE__ */ new Map());
+    }
+    const agentStates = this.stateByRun.get(agentId);
+    if (!agentStates.has(threadId)) {
+      agentStates.set(threadId, /* @__PURE__ */ new Map());
+    }
+    const threadStates = agentStates.get(threadId);
+    threadStates.set(runId, JSON.parse(JSON.stringify(state)));
+  }
+  /**
+   * Associate a message with a run
+   */
+  associateMessageWithRun(agentId, threadId, messageId, runId) {
+    if (!this.messageToRun.has(agentId)) {
+      this.messageToRun.set(agentId, /* @__PURE__ */ new Map());
+    }
+    const agentMessages = this.messageToRun.get(agentId);
+    if (!agentMessages.has(threadId)) {
+      agentMessages.set(threadId, /* @__PURE__ */ new Map());
+    }
+    const threadMessages = agentMessages.get(threadId);
+    threadMessages.set(messageId, runId);
+  }
+  /**
+   * Clear all state for an agent
+   */
+  clearAgentState(agentId) {
+    this.stateByRun.delete(agentId);
+    this.messageToRun.delete(agentId);
+  }
+  /**
+   * Clear all state for a thread
+   */
+  clearThreadState(agentId, threadId) {
+    this.stateByRun.get(agentId)?.delete(threadId);
+    this.messageToRun.get(agentId)?.delete(threadId);
+  }
+};
+
 // src/core/core.ts
 var CopilotKitCoreErrorCode = /* @__PURE__ */ ((CopilotKitCoreErrorCode2) => {
   CopilotKitCoreErrorCode2["RUNTIME_INFO_FETCH_FAILED"] = "runtime_info_fetch_failed";
@@ -1115,6 +1297,7 @@ var CopilotKitCore = class {
   contextStore;
   suggestionEngine;
   runHandler;
+  stateManager;
   constructor({
     runtimeUrl,
     headers = {},
@@ -1129,13 +1312,24 @@ var CopilotKitCore = class {
     this.contextStore = new ContextStore(this);
     this.suggestionEngine = new SuggestionEngine(this);
     this.runHandler = new RunHandler(this);
+    this.stateManager = new StateManager(this);
     this.agentRegistry.initialize(agents__unsafe_dev_only);
     this.runHandler.initialize(tools);
     this.suggestionEngine.initialize(suggestionsConfig);
+    this.stateManager.initialize();
     this.agentRegistry.setRuntimeUrl(runtimeUrl);
+    this.subscribe({
+      onAgentsChanged: ({ agents }) => {
+        Object.values(agents).forEach((agent) => {
+          if (agent.agentId) {
+            this.stateManager.subscribeToAgent(agent);
+          }
+        });
+      }
+    });
   }
   /**
-   * Internal method used by delegate classes to notify subscribers
+   * Internal method used by delegate classes and subclasses to notify subscribers
    */
   async notifySubscribers(handler, errorMessage) {
     await Promise.all(
@@ -1298,6 +1492,18 @@ var CopilotKitCore = class {
   async runAgent(params) {
     return this.runHandler.runAgent(params);
   }
+  /**
+   * State management (delegated to StateManager)
+   */
+  getStateByRun(agentId, threadId, runId) {
+    return this.stateManager.getStateByRun(agentId, threadId, runId);
+  }
+  getRunIdForMessage(agentId, threadId, messageId) {
+    return this.stateManager.getRunIdForMessage(agentId, threadId, messageId);
+  }
+  getRunIdsForThread(agentId, threadId) {
+    return this.stateManager.getRunIdsForThread(agentId, threadId);
+  }
   /**
    * Internal method used by RunHandler to build frontend tools
    */
@@ -1537,6 +1743,7 @@ export {
   CopilotKitCoreRuntimeConnectionStatus,
   ProxiedCopilotRuntimeAgent,
   RunHandler,
+  StateManager,
   SuggestionEngine,
   ToolCallStatus,
   completePartialMarkdown