@copilotkit/react-core 0.0.0-fix-debug-infosys-20251107162427 → 0.0.0-fix-restore-handle-method-node-http-20260105204107

package/dist/hooks/index.js

@@ -79,17 +79,15 @@ var __async = (__this, __arguments, generator) => {
 // src/hooks/index.ts
 var hooks_exports = {};
 __export(hooks_exports, {
-  runAgent: () => runAgent,
-  startAgent: () => startAgent,
-  stopAgent: () => stopAgent,
   useCoAgent: () => useCoAgent,
   useCoAgentStateRender: () => useCoAgentStateRender,
   useCopilotAction: () => useCopilotAction,
   useCopilotAdditionalInstructions: () => useCopilotAdditionalInstructions,
   useCopilotAuthenticatedAction_c: () => useCopilotAuthenticatedAction_c,
-  useCopilotChat: () => useCopilotChat2,
+  useCopilotChat: () => useCopilotChat,
   useCopilotChatHeadless_c: () => useCopilotChatHeadless_c,
-  useCopilotChatInternal: () => useCopilotChat,
+  useCopilotChatInternal: () => useCopilotChatInternal,
+  useCopilotChatSuggestions: () => useCopilotChatSuggestions,
   useCopilotReadable: () => useCopilotReadable,
   useCopilotRuntimeClient: () => useCopilotRuntimeClient,
   useDefaultTool: () => useDefaultTool,
@@ -97,13 +95,14 @@ __export(hooks_exports, {
   useHumanInTheLoop: () => useHumanInTheLoop,
   useLangGraphInterrupt: () => useLangGraphInterrupt,
   useLangGraphInterruptRender: () => useLangGraphInterruptRender,
+  useLazyToolRenderer: () => useLazyToolRenderer,
   useMakeCopilotDocumentReadable: () => useMakeCopilotDocumentReadable,
-  useRenderToolCall: () => useRenderToolCall
+  useRenderToolCall: () => useRenderToolCall2
 });
 module.exports = __toCommonJS(hooks_exports);
 
 // src/hooks/use-copilot-chat_internal.ts
-var import_react10 = require("react");
+var import_react13 = require("react");
 
 // src/context/copilot-context.tsx
 var import_react = __toESM(require("react"));
@@ -113,10 +112,8 @@ var emptyCopilotContext = {
   },
   removeAction: () => {
   },
-  coAgentStateRenders: {},
-  setCoAgentStateRender: () => {
-  },
-  removeCoAgentStateRender: () => {
+  setRegisteredActions: () => "",
+  removeRegisteredAction: () => {
   },
   chatComponentsCache: { current: { actions: {}, coAgentStateRenders: {} } },
   getContextString: (documents, categories) => returnAndThrowInDebug(""),
@@ -136,7 +133,6 @@ var emptyCopilotContext = {
   addDocumentContext: () => returnAndThrowInDebug(""),
   removeDocumentContext: () => {
   },
-  runtimeClient: {},
   copilotApiConfig: new class {
     get chatApiEndpoint() {
       throw new Error("Remember to wrap your app in a `<CopilotKit> {...} </CopilotKit>` !!!");
@@ -176,10 +172,15 @@ var emptyCopilotContext = {
   extensions: {},
   setExtensions: () => {
   },
-  langGraphInterruptAction: null,
-  setLangGraphInterruptAction: () => {
+  interruptActions: {},
+  setInterruptAction: () => {
+  },
+  removeInterruptAction: () => {
   },
-  removeLangGraphInterruptAction: () => {
+  interruptEventQueue: {},
+  addInterruptEvent: () => {
+  },
+  resolveInterruptEvent: () => {
   },
   onError: () => {
   },
@@ -204,186 +205,22 @@ function returnAndThrowInDebug(_value) {
   throw new Error("Remember to wrap your app in a `<CopilotKit> {...} </CopilotKit>` !!!");
 }
 
-// src/context/copilot-messages-context.tsx
-var import_react2 = __toESM(require("react"));
-var emptyCopilotContext2 = {
-  messages: [],
-  setMessages: () => [],
-  // suggestions state
-  suggestions: [],
-  setSuggestions: () => []
-};
-var CopilotMessagesContext = import_react2.default.createContext(emptyCopilotContext2);
-function useCopilotMessagesContext() {
-  const context = import_react2.default.useContext(CopilotMessagesContext);
-  if (context === emptyCopilotContext2) {
-    throw new Error(
-      "A messages consuming component was not wrapped with `<CopilotMessages> {...} </CopilotMessages>`"
-    );
-  }
-  return context;
-}
-
-// src/hooks/use-chat.ts
-var import_react6 = require("react");
-var import_react_dom = require("react-dom");
-var import_shared4 = require("@copilotkit/shared");
-var import_runtime_client_gql3 = require("@copilotkit/runtime-client-gql");
-
-// src/types/frontend-action.ts
-var import_runtime_client_gql = require("@copilotkit/runtime-client-gql");
-var import_shared = require("@copilotkit/shared");
-function processActionsForRuntimeRequest(actions) {
-  const filteredActions = actions.filter(
-    (action) => action.available !== import_runtime_client_gql.ActionInputAvailability.Disabled && action.disabled !== true && action.name !== "*" && action.available != "frontend" && !action.pairedAction
-  ).map((action) => {
-    let available = import_runtime_client_gql.ActionInputAvailability.Enabled;
-    if (action.disabled) {
-      available = import_runtime_client_gql.ActionInputAvailability.Disabled;
-    } else if (action.available === "disabled") {
-      available = import_runtime_client_gql.ActionInputAvailability.Disabled;
-    } else if (action.available === "remote") {
-      available = import_runtime_client_gql.ActionInputAvailability.Remote;
-    }
-    return {
-      name: action.name,
-      description: action.description || "",
-      jsonSchema: JSON.stringify((0, import_shared.actionParametersToJsonSchema)(action.parameters || [])),
-      available
-    };
-  });
-  return filteredActions;
-}
-
-// src/hooks/use-copilot-runtime-client.ts
-var import_runtime_client_gql2 = require("@copilotkit/runtime-client-gql");
+// src/components/error-boundary/error-utils.tsx
+var import_react3 = require("react");
 
 // src/components/toast/toast-provider.tsx
-var import_react3 = require("react");
-var import_shared2 = require("@copilotkit/shared");
+var import_react2 = require("react");
+var import_shared = require("@copilotkit/shared");
 var import_jsx_runtime = require("react/jsx-runtime");
-var ToastContext = (0, import_react3.createContext)(void 0);
+var ToastContext = (0, import_react2.createContext)(void 0);
 function useToast() {
-  const context = (0, import_react3.useContext)(ToastContext);
+  const context = (0, import_react2.useContext)(ToastContext);
   if (!context) {
     throw new Error("useToast must be used within a ToastProvider");
   }
   return context;
 }
 
-// src/hooks/use-copilot-runtime-client.ts
-var import_react4 = require("react");
-var import_shared3 = require("@copilotkit/shared");
-var useCopilotRuntimeClient = (options) => {
-  const { setBannerError } = useToast();
-  const _a = options, { showDevConsole, onError } = _a, runtimeOptions = __objRest(_a, ["showDevConsole", "onError"]);
-  const lastStructuredErrorRef = (0, import_react4.useRef)(null);
-  const traceUIError = (error, originalError) => __async(void 0, null, function* () {
-    try {
-      const errorEvent = {
-        type: "error",
-        timestamp: Date.now(),
-        context: {
-          source: "ui",
-          request: {
-            operation: "runtimeClient",
-            url: runtimeOptions.url,
-            startTime: Date.now()
-          },
-          technical: {
-            environment: "browser",
-            userAgent: typeof navigator !== "undefined" ? navigator.userAgent : void 0,
-            stackTrace: originalError instanceof Error ? originalError.stack : void 0
-          }
-        },
-        error
-      };
-      yield onError(errorEvent);
-    } catch (error2) {
-      console.error("Error in onError handler:", error2);
-    }
-  });
-  const runtimeClient = (0, import_react4.useMemo)(() => {
-    return new import_runtime_client_gql2.CopilotRuntimeClient(__spreadProps(__spreadValues({}, runtimeOptions), {
-      handleGQLErrors: (error) => {
-        var _a2;
-        if ((_a2 = error.graphQLErrors) == null ? void 0 : _a2.length) {
-          const graphQLErrors = error.graphQLErrors;
-          const routeError = (gqlError) => {
-            const extensions = gqlError.extensions;
-            const visibility = extensions == null ? void 0 : extensions.visibility;
-            if (visibility === import_shared3.ErrorVisibility.SILENT) {
-              console.error("CopilotKit Silent Error:", gqlError.message);
-              return;
-            }
-            const now = Date.now();
-            const errorMessage = gqlError.message;
-            if (lastStructuredErrorRef.current && lastStructuredErrorRef.current.message === errorMessage && now - lastStructuredErrorRef.current.timestamp < 150) {
-              return;
-            }
-            lastStructuredErrorRef.current = { message: errorMessage, timestamp: now };
-            const ckError = createStructuredError(gqlError);
-            if (ckError) {
-              setBannerError(ckError);
-              traceUIError(ckError, gqlError);
-            } else {
-              const fallbackError = new import_shared3.CopilotKitError({
-                message: gqlError.message,
-                code: import_shared3.CopilotKitErrorCode.UNKNOWN
-              });
-              setBannerError(fallbackError);
-              traceUIError(fallbackError, gqlError);
-            }
-          };
-          graphQLErrors.forEach(routeError);
-        } else {
-          const fallbackError = new import_shared3.CopilotKitError({
-            message: (error == null ? void 0 : error.message) || String(error),
-            code: import_shared3.CopilotKitErrorCode.UNKNOWN
-          });
-          setBannerError(fallbackError);
-          traceUIError(fallbackError, error);
-        }
-      },
-      handleGQLWarning: (message) => {
-        console.warn(message);
-        const warningError = new import_shared3.CopilotKitError({
-          message,
-          code: import_shared3.CopilotKitErrorCode.UNKNOWN
-        });
-        setBannerError(warningError);
-      }
-    }));
-  }, [runtimeOptions, setBannerError, onError]);
-  return runtimeClient;
-};
-function createStructuredError(gqlError) {
-  var _a, _b, _c;
-  const extensions = gqlError.extensions;
-  const originalError = extensions == null ? void 0 : extensions.originalError;
-  const message = (originalError == null ? void 0 : originalError.message) || gqlError.message;
-  const code = extensions == null ? void 0 : extensions.code;
-  if (code) {
-    return new import_shared3.CopilotKitError({ message, code });
-  }
-  if ((_a = originalError == null ? void 0 : originalError.stack) == null ? void 0 : _a.includes("CopilotApiDiscoveryError")) {
-    return new import_shared3.CopilotKitApiDiscoveryError({ message });
-  }
-  if ((_b = originalError == null ? void 0 : originalError.stack) == null ? void 0 : _b.includes("CopilotKitRemoteEndpointDiscoveryError")) {
-    return new import_shared3.CopilotKitRemoteEndpointDiscoveryError({ message });
-  }
-  if ((_c = originalError == null ? void 0 : originalError.stack) == null ? void 0 : _c.includes("CopilotKitAgentDiscoveryError")) {
-    return new import_shared3.CopilotKitAgentDiscoveryError({
-      agentName: "",
-      availableAgents: []
-    });
-  }
-  return null;
-}
-
-// src/components/error-boundary/error-utils.tsx
-var import_react5 = require("react");
-
 // src/components/toast/exclamation-mark-icon.tsx
 var import_jsx_runtime2 = require("react/jsx-runtime");
 var ExclamationMarkIcon = ({
@@ -465,9 +302,9 @@ function ErrorToast({ errors }) {
 }
 function useErrorToast() {
   const { addToast } = useToast();
-  return (0, import_react5.useCallback)(
-    (error) => {
-      const errorId = error.map((err) => {
+  return (0, import_react3.useCallback)(
+    (errors) => {
+      const errorId = errors.map((err) => {
         var _a, _b;
         const message = "extensions" in err ? ((_b = (_a = err.extensions) == null ? void 0 : _a.originalError) == null ? void 0 : _b.message) || err.message : err.message;
         const stack = err.stack || "";
@@ -477,7 +314,7 @@ function useErrorToast() {
         type: "error",
         id: errorId,
         // Toast libraries typically dedupe by id
-        message: /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(ErrorToast, { errors: error })
+        message: /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(ErrorToast, { errors })
       });
     },
     [addToast]
@@ -485,7 +322,7 @@ function useErrorToast() {
 }
 function useAsyncCallback(callback, deps) {
   const addErrorToast = useErrorToast();
-  return (0, import_react5.useCallback)((...args) => __async(this, null, function* () {
+  return (0, import_react3.useCallback)((...args) => __async(this, null, function* () {
     try {
       return yield callback(...args);
     } catch (error) {
@@ -496,1249 +333,571 @@ function useAsyncCallback(callback, deps) {
   }), deps);
 }
 
-// src/hooks/use-chat.ts
-function useChat(options) {
+// src/hooks/use-copilot-chat_internal.ts
+var import_runtime_client_gql2 = require("@copilotkit/runtime-client-gql");
+
+// src/context/coagent-state-renders-context.tsx
+var import_react4 = require("react");
+var import_jsx_runtime4 = require("react/jsx-runtime");
+var CoAgentStateRendersContext = (0, import_react4.createContext)(
+  void 0
+);
+function useCoAgentStateRenders() {
+  const context = (0, import_react4.useContext)(CoAgentStateRendersContext);
+  if (!context) {
+    throw new Error("useCoAgentStateRenders must be used within CoAgentStateRendersProvider");
+  }
+  return context;
+}
+
+// src/hooks/use-langgraph-interrupt-render.ts
+var import_react7 = __toESM(require("react"));
+var import_runtime_client_gql = require("@copilotkit/runtime-client-gql");
+var import_shared2 = require("@copilotkit/shared");
+
+// src/hooks/use-agent-nodename.ts
+var import_react5 = require("react");
+var import_react6 = require("@copilotkitnext/react");
+function useAgentNodeName(agentName) {
+  const { agent } = (0, import_react6.useAgent)({ agentId: agentName });
+  const nodeNameRef = (0, import_react5.useRef)("start");
+  (0, import_react5.useEffect)(() => {
+    if (!agent)
+      return;
+    const subscriber = {
+      onStepStartedEvent: ({ event }) => {
+        nodeNameRef.current = event.stepName;
+      },
+      onRunStartedEvent: () => {
+        nodeNameRef.current = "start";
+      },
+      onRunFinishedEvent: () => {
+        nodeNameRef.current = "end";
+      }
+    };
+    const subscription = agent.subscribe(subscriber);
+    return () => {
+      subscription.unsubscribe();
+    };
+  }, [agent]);
+  return nodeNameRef.current;
+}
+
+// src/hooks/use-langgraph-interrupt-render.ts
+var import_react8 = require("@copilotkitnext/react");
+var InterruptRenderer = ({ event, result, render, resolve }) => {
+  return render({ event, result, resolve });
+};
+function useLangGraphInterruptRender(agent) {
+  var _a;
   const {
-    messages,
-    setMessages,
-    makeSystemMessageCallback,
-    copilotConfig,
-    setIsLoading,
-    initialMessages,
-    isLoading,
-    actions,
-    onFunctionCall,
-    onCoAgentStateRender,
-    setCoagentStatesWithRef,
-    coagentStatesRef,
+    interruptActions,
     agentSession,
-    setAgentSession,
     threadId,
-    setThreadId,
-    runId,
-    setRunId,
-    chatAbortControllerRef,
-    agentLock,
-    extensions,
-    setExtensions,
-    langGraphInterruptAction,
-    setLangGraphInterruptAction,
-    disableSystemMessage = false
-  } = options;
-  const runChatCompletionRef = (0, import_react6.useRef)();
-  const addErrorToast = useErrorToast();
-  const { setBannerError } = useToast();
-  const { onError, showDevConsole, getAllContext } = useCopilotContext();
-  const copilotReadableContext = getAllContext();
-  const context = (0, import_react6.useMemo)(
-    () => copilotReadableContext.map((contextItem) => {
-      const [description, ...valueParts] = contextItem.value.split(":");
-      return {
-        description: description.trim(),
-        value: valueParts.join(":").trim()
-      };
-    }),
-    [copilotReadableContext]
-  );
-  const traceUIError = (error, originalError) => __async(this, null, function* () {
-    try {
-      const traceEvent = {
-        type: "error",
-        timestamp: Date.now(),
-        context: {
-          source: "ui",
-          request: {
-            operation: "useChatCompletion",
-            url: copilotConfig.chatApiEndpoint,
-            startTime: Date.now()
-          },
-          technical: {
-            environment: "browser",
-            userAgent: typeof navigator !== "undefined" ? navigator.userAgent : void 0,
-            stackTrace: originalError instanceof Error ? originalError.stack : void 0
-          }
-        },
-        error
-      };
-      yield onError(traceEvent);
-    } catch (traceError) {
-      console.error("Error in use-chat onError handler:", traceError);
-    }
-  });
-  const agentSessionRef = (0, import_react6.useRef)(agentSession);
-  agentSessionRef.current = agentSession;
-  const runIdRef = (0, import_react6.useRef)(runId);
-  runIdRef.current = runId;
-  const extensionsRef = (0, import_react6.useRef)(extensions);
-  extensionsRef.current = extensions;
-  const publicApiKey = copilotConfig.publicApiKey;
-  const headers = __spreadValues(__spreadValues({}, copilotConfig.headers || {}), publicApiKey ? { [import_shared4.COPILOT_CLOUD_PUBLIC_API_KEY_HEADER]: publicApiKey } : {});
-  const runtimeClient = useCopilotRuntimeClient({
-    url: copilotConfig.chatApiEndpoint,
-    publicApiKey: copilotConfig.publicApiKey,
-    headers,
-    credentials: copilotConfig.credentials,
-    showDevConsole,
-    onError
-  });
-  const pendingAppendsRef = (0, import_react6.useRef)([]);
-  const runChatCompletion = useAsyncCallback(
-    (previousMessages) => __async(this, null, function* () {
-      var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q, _r, _s, _t;
-      setIsLoading(true);
-      const interruptEvent = langGraphInterruptAction == null ? void 0 : langGraphInterruptAction.event;
-      if ((interruptEvent == null ? void 0 : interruptEvent.name) === import_runtime_client_gql3.MetaEventName.LangGraphInterruptEvent && (interruptEvent == null ? void 0 : interruptEvent.value) && !(interruptEvent == null ? void 0 : interruptEvent.response) && agentSessionRef.current) {
-        addErrorToast([
-          new Error(
-            "A message was sent while interrupt is active. This will cause failure on the agent side"
-          )
-        ]);
-      }
-      let newMessages = [
-        new import_runtime_client_gql3.TextMessage({
-          content: "",
-          role: import_runtime_client_gql3.Role.Assistant
-        })
-      ];
-      chatAbortControllerRef.current = new AbortController();
-      setMessages([...previousMessages, ...newMessages]);
-      const messagesWithContext = disableSystemMessage ? [...initialMessages || [], ...previousMessages] : [makeSystemMessageCallback(), ...initialMessages || [], ...previousMessages];
-      const finalProperties = __spreadValues({}, copilotConfig.properties || {});
-      let mcpServersToUse = null;
-      if (copilotConfig.mcpServers && Array.isArray(copilotConfig.mcpServers) && copilotConfig.mcpServers.length > 0) {
-        mcpServersToUse = copilotConfig.mcpServers;
-      } else if (((_a = copilotConfig.properties) == null ? void 0 : _a.mcpServers) && Array.isArray(copilotConfig.properties.mcpServers) && copilotConfig.properties.mcpServers.length > 0) {
-        mcpServersToUse = copilotConfig.properties.mcpServers;
-      }
-      if (mcpServersToUse) {
-        finalProperties.mcpServers = mcpServersToUse;
-        copilotConfig.mcpServers = mcpServersToUse;
-      }
-      const isAgentRun = agentSessionRef.current !== null;
-      const stream = runtimeClient.asStream(
-        runtimeClient.generateCopilotResponse({
-          data: __spreadProps(__spreadValues(__spreadProps(__spreadValues({
-            frontend: {
-              actions: processActionsForRuntimeRequest(actions),
-              url: window.location.href
-            },
+    interruptEventQueue,
+    addInterruptEvent,
+    resolveInterruptEvent
+  } = useCopilotContext();
+  const existingConfig = (0, import_react8.useCopilotChatConfiguration)();
+  const resolvedAgentId = (_a = existingConfig == null ? void 0 : existingConfig.agentId) != null ? _a : "default";
+  const nodeName = useAgentNodeName(resolvedAgentId);
+  (0, import_react7.useEffect)(() => {
+    if (!agent)
+      return;
+    let localInterrupt = null;
+    const subscriber = {
+      onCustomEvent: ({ event }) => {
+        if (event.name === "on_interrupt") {
+          const eventData = {
+            name: import_runtime_client_gql.MetaEventName.LangGraphInterruptEvent,
+            type: event.type,
+            value: (0, import_shared2.parseJson)(event.value, event.value)
+          };
+          const eventId = (0, import_shared2.dataToUUID)(eventData, "interruptEvents");
+          localInterrupt = {
+            eventId,
             threadId,
-            runId: runIdRef.current,
-            extensions: extensionsRef.current,
-            metaEvents: composeAndFlushMetaEventsInput([langGraphInterruptAction == null ? void 0 : langGraphInterruptAction.event]),
-            messages: (0, import_runtime_client_gql3.convertMessagesToGqlInput)((0, import_runtime_client_gql3.filterAgentStateMessages)(messagesWithContext))
-          }, copilotConfig.cloud ? {
-            cloud: __spreadValues({}, ((_d = (_c = (_b = copilotConfig.cloud.guardrails) == null ? void 0 : _b.input) == null ? void 0 : _c.restrictToTopic) == null ? void 0 : _d.enabled) ? {
-              guardrails: {
-                inputValidationRules: {
-                  allowList: copilotConfig.cloud.guardrails.input.restrictToTopic.validTopics,
-                  denyList: copilotConfig.cloud.guardrails.input.restrictToTopic.invalidTopics
-                }
-              }
-            } : {})
-          } : {}), {
-            metadata: {
-              requestType: import_runtime_client_gql3.CopilotRequestType.Chat
-            }
-          }), agentSessionRef.current ? {
-            agentSession: agentSessionRef.current
-          } : {}), {
-            agentStates: Object.values(coagentStatesRef.current).map((state) => {
-              const stateObject = {
-                agentName: state.name,
-                state: JSON.stringify(state.state)
-              };
-              if (state.config !== void 0) {
-                stateObject.config = JSON.stringify(state.config);
-              }
-              return stateObject;
-            }),
-            forwardedParameters: options.forwardedParameters || {},
-            context
-          }),
-          properties: finalProperties,
-          signal: (_e = chatAbortControllerRef.current) == null ? void 0 : _e.signal
-        })
-      );
-      const guardrailsEnabled = ((_h = (_g = (_f = copilotConfig.cloud) == null ? void 0 : _f.guardrails) == null ? void 0 : _g.input) == null ? void 0 : _h.restrictToTopic.enabled) || false;
-      const reader = stream.getReader();
-      let executedCoAgentStateRenders = [];
-      let followUp = void 0;
-      let messages2 = [];
-      let syncedMessages = [];
-      let interruptMessages = [];
-      try {
-        while (true) {
-          let done, value;
-          try {
-            const readResult = yield reader.read();
-            done = readResult.done;
-            value = readResult.value;
-          } catch (readError) {
-            break;
-          }
-          if (done) {
-            if (chatAbortControllerRef.current.signal.aborted) {
-              return [];
-            }
-            break;
-          }
-          if (!(value == null ? void 0 : value.generateCopilotResponse)) {
-            continue;
-          }
-          runIdRef.current = value.generateCopilotResponse.runId || null;
-          extensionsRef.current = import_runtime_client_gql3.CopilotRuntimeClient.removeGraphQLTypename(
-            value.generateCopilotResponse.extensions || {}
-          );
-          setRunId(runIdRef.current);
-          setExtensions(extensionsRef.current);
-          let rawMessagesResponse = value.generateCopilotResponse.messages;
-          const metaEvents = (_j = (_i = value.generateCopilotResponse) == null ? void 0 : _i.metaEvents) != null ? _j : [];
-          (metaEvents != null ? metaEvents : []).forEach((ev) => {
-            if (ev.name === import_runtime_client_gql3.MetaEventName.LangGraphInterruptEvent) {
-              let eventValue = (0, import_runtime_client_gql3.langGraphInterruptEvent)(ev).value;
-              eventValue = (0, import_shared4.parseJson)(eventValue, eventValue);
-              setLangGraphInterruptAction(threadId, {
-                event: __spreadProps(__spreadValues({}, (0, import_runtime_client_gql3.langGraphInterruptEvent)(ev)), {
-                  value: eventValue
-                })
-              });
-            }
-            if (ev.name === import_runtime_client_gql3.MetaEventName.CopilotKitLangGraphInterruptEvent) {
-              const data = ev.data;
-              rawMessagesResponse = [...rawMessagesResponse, ...data.messages];
-              interruptMessages = (0, import_runtime_client_gql3.convertGqlOutputToMessages)(
-                // @ts-ignore
-                (0, import_runtime_client_gql3.filterAdjacentAgentStateMessages)(data.messages)
-              );
-            }
-          });
-          messages2 = (0, import_runtime_client_gql3.convertGqlOutputToMessages)(
-            (0, import_runtime_client_gql3.filterAdjacentAgentStateMessages)(rawMessagesResponse)
-          );
-          newMessages = [];
-          if (((_k = value.generateCopilotResponse.status) == null ? void 0 : _k.__typename) === "FailedResponseStatus" && value.generateCopilotResponse.status.reason === "GUARDRAILS_VALIDATION_FAILED") {
-            const guardrailsReason = ((_l = value.generateCopilotResponse.status.details) == null ? void 0 : _l.guardrailsReason) || "";
-            newMessages = [
-              new import_runtime_client_gql3.TextMessage({
-                role: import_runtime_client_gql3.MessageRole.Assistant,
-                content: guardrailsReason
-              })
-            ];
-            const guardrailsError = new import_shared4.CopilotKitError({
-              message: `Guardrails validation failed: ${guardrailsReason}`,
-              code: import_shared4.CopilotKitErrorCode.MISUSE
-            });
-            yield traceUIError(guardrailsError, {
-              statusReason: value.generateCopilotResponse.status.reason,
-              statusDetails: value.generateCopilotResponse.status.details
-            });
-            setMessages([...previousMessages, ...newMessages]);
-            break;
-          }
-          if (((_m = value.generateCopilotResponse.status) == null ? void 0 : _m.__typename) === "FailedResponseStatus" && value.generateCopilotResponse.status.reason === "UNKNOWN_ERROR") {
-            const errorMessage = ((_n = value.generateCopilotResponse.status.details) == null ? void 0 : _n.description) || "An unknown error occurred";
-            const statusDetails = value.generateCopilotResponse.status.details;
-            const originalError = (statusDetails == null ? void 0 : statusDetails.originalError) || (statusDetails == null ? void 0 : statusDetails.error);
-            const originalCode = (originalError == null ? void 0 : originalError.code) || ((_o = originalError == null ? void 0 : originalError.extensions) == null ? void 0 : _o.code);
-            const originalSeverity = (originalError == null ? void 0 : originalError.severity) || ((_p = originalError == null ? void 0 : originalError.extensions) == null ? void 0 : _p.severity);
-            const originalVisibility = (originalError == null ? void 0 : originalError.visibility) || ((_q = originalError == null ? void 0 : originalError.extensions) == null ? void 0 : _q.visibility);
-            let errorCode = import_shared4.CopilotKitErrorCode.NETWORK_ERROR;
-            if (originalCode && Object.values(import_shared4.CopilotKitErrorCode).includes(originalCode)) {
-              errorCode = originalCode;
-            }
-            const structuredError = new import_shared4.CopilotKitError({
-              message: errorMessage,
-              code: errorCode,
-              severity: originalSeverity,
-              visibility: originalVisibility
-            });
-            setBannerError(structuredError);
-            yield traceUIError(structuredError, {
-              statusReason: value.generateCopilotResponse.status.reason,
-              statusDetails: value.generateCopilotResponse.status.details,
-              originalErrorCode: originalCode,
-              preservedStructure: !!originalCode
-            });
-            setIsLoading(false);
-            throw new Error(structuredError.message);
-          } else if (messages2.length > 0) {
-            newMessages = [...messages2];
-            for (const message of messages2) {
-              if (message.isAgentStateMessage() && !message.active && !executedCoAgentStateRenders.includes(message.id) && onCoAgentStateRender) {
-                if (guardrailsEnabled && value.generateCopilotResponse.status === void 0) {
-                  break;
-                }
-                yield onCoAgentStateRender({
-                  name: message.agentName,
-                  nodeName: message.nodeName,
-                  state: message.state
-                });
-                executedCoAgentStateRenders.push(message.id);
-              }
-            }
-            const lastAgentStateMessage = [...messages2].reverse().find((message) => message.isAgentStateMessage());
-            if (lastAgentStateMessage) {
-              if (lastAgentStateMessage.state.messages && lastAgentStateMessage.state.messages.length > 0) {
-                syncedMessages = (0, import_runtime_client_gql3.loadMessagesFromJsonRepresentation)(
-                  lastAgentStateMessage.state.messages
-                );
-              }
-              setCoagentStatesWithRef((prevAgentStates) => {
-                var _a2;
-                return __spreadProps(__spreadValues({}, prevAgentStates), {
-                  [lastAgentStateMessage.agentName]: {
-                    name: lastAgentStateMessage.agentName,
-                    state: lastAgentStateMessage.state,
-                    running: lastAgentStateMessage.running,
-                    active: lastAgentStateMessage.active,
-                    threadId: lastAgentStateMessage.threadId,
-                    nodeName: lastAgentStateMessage.nodeName,
-                    runId: lastAgentStateMessage.runId,
-                    // Preserve existing config from previous state
-                    config: (_a2 = prevAgentStates[lastAgentStateMessage.agentName]) == null ? void 0 : _a2.config
-                  }
-                });
-              });
-              if (lastAgentStateMessage.running) {
-                setAgentSession({
-                  threadId: lastAgentStateMessage.threadId,
-                  agentName: lastAgentStateMessage.agentName,
-                  nodeName: lastAgentStateMessage.nodeName
-                });
-              } else {
-                if (agentLock) {
-                  setAgentSession({
-                    threadId: (0, import_shared4.randomId)(),
-                    agentName: agentLock,
-                    nodeName: void 0
-                  });
-                } else {
-                  setAgentSession(null);
-                }
-              }
-            }
-          }
-          if (newMessages.length > 0) {
-            setMessages([...previousMessages, ...newMessages]);
-          }
+            event: eventData
+          };
         }
-        let finalMessages = constructFinalMessages(
-          [...syncedMessages, ...interruptMessages],
-          previousMessages,
-          newMessages
-        );
-        let didExecuteAction = false;
-        const executeActionFromMessage = (currentAction, actionMessage) => __async(this, null, function* () {
-          var _a2;
-          const isInterruptAction = interruptMessages.find((m) => m.id === actionMessage.id);
-          followUp = (_a2 = currentAction == null ? void 0 : currentAction.followUp) != null ? _a2 : !isInterruptAction;
-          if (currentAction == null ? void 0 : currentAction._setActivatingMessageId) {
-            currentAction._setActivatingMessageId(actionMessage.id);
-          }
-          const resultMessage = yield executeAction({
-            onFunctionCall,
-            message: actionMessage,
-            chatAbortControllerRef,
-            onError: (error) => {
-              addErrorToast([error]);
-              console.error(`Failed to execute action ${actionMessage.name}: ${error}`);
-            },
-            setMessages,
-            getFinalMessages: () => finalMessages,
-            isRenderAndWait: (currentAction == null ? void 0 : currentAction._isRenderAndWait) || false
-          });
-          didExecuteAction = true;
-          const messageIndex = finalMessages.findIndex((msg) => msg.id === actionMessage.id);
-          finalMessages.splice(messageIndex + 1, 0, resultMessage);
-          if (currentAction == null ? void 0 : currentAction._isRenderAndWait) {
-            const messagesForImmediateUpdate = [...finalMessages];
-            (0, import_react_dom.flushSync)(() => {
-              setMessages(messagesForImmediateUpdate);
-            });
-          }
-          if (currentAction == null ? void 0 : currentAction._setActivatingMessageId) {
-            currentAction._setActivatingMessageId(null);
-          }
-          return resultMessage;
-        });
-        if (onFunctionCall) {
-          const lastMessages = [];
-          for (let i = finalMessages.length - 1; i >= 0; i--) {
-            const message = finalMessages[i];
-            if ((message.isActionExecutionMessage() || message.isResultMessage()) && message.status.code !== import_runtime_client_gql3.MessageStatusCode.Pending) {
-              lastMessages.unshift(message);
-            } else if (!message.isAgentStateMessage()) {
-              break;
-            }
-          }
-          for (const message of lastMessages) {
-            setMessages(finalMessages);
-            const action = actions.find(
-              (action2) => action2.name === message.name
-            );
-            if (action && action.available === "frontend") {
-              continue;
-            }
-            const currentResultMessagePairedFeAction = message.isResultMessage() ? getPairedFeAction(actions, message) : null;
-            if (action && message.isActionExecutionMessage()) {
-              const isRenderAndWaitAction = (action == null ? void 0 : action._isRenderAndWait) || false;
-              const alreadyProcessed = isRenderAndWaitAction && finalMessages.some(
-                (fm) => fm.isResultMessage() && fm.actionExecutionId === message.id
-              );
-              if (alreadyProcessed) {
-              } else {
-                const resultMessage = yield executeActionFromMessage(
-                  action,
-                  message
-                );
-                const pairedFeAction = getPairedFeAction(actions, resultMessage);
-                if (pairedFeAction) {
-                  const newExecutionMessage = new import_runtime_client_gql3.ActionExecutionMessage({
-                    name: pairedFeAction.name,
-                    arguments: (0, import_shared4.parseJson)(resultMessage.result, resultMessage.result),
-                    status: message.status,
-                    createdAt: message.createdAt,
-                    parentMessageId: message.parentMessageId
-                  });
-                  yield executeActionFromMessage(pairedFeAction, newExecutionMessage);
-                }
-              }
-            } else if (message.isResultMessage() && currentResultMessagePairedFeAction) {
-              const newExecutionMessage = new import_runtime_client_gql3.ActionExecutionMessage({
-                name: currentResultMessagePairedFeAction.name,
-                arguments: (0, import_shared4.parseJson)(message.result, message.result),
-                status: message.status,
-                createdAt: message.createdAt
-              });
-              finalMessages.push(newExecutionMessage);
-              yield executeActionFromMessage(
-                currentResultMessagePairedFeAction,
-                newExecutionMessage
-              );
-            }
-          }
-          setMessages(finalMessages);
+      },
+      onRunStartedEvent: () => {
+        localInterrupt = null;
+      },
+      onRunFinalized: () => {
+        if (localInterrupt) {
+          addInterruptEvent(localInterrupt);
+          localInterrupt = null;
         }
-        if (followUp !== false && (didExecuteAction || // the last message is a server side result
-        !isAgentRun && finalMessages.length && finalMessages[finalMessages.length - 1].isResultMessage()) && // the user did not stop generation
-        !((_r = chatAbortControllerRef.current) == null ? void 0 : _r.signal.aborted)) {
-          yield new Promise((resolve) => setTimeout(resolve, 10));
-          return yield runChatCompletionRef.current(finalMessages);
-        } else if ((_s = chatAbortControllerRef.current) == null ? void 0 : _s.signal.aborted) {
-          const repairedMessages = finalMessages.filter((message, actionExecutionIndex) => {
-            if (message.isActionExecutionMessage()) {
-              return finalMessages.find(
-                (msg, resultIndex) => msg.isResultMessage() && msg.actionExecutionId === message.id && resultIndex === actionExecutionIndex + 1
-              );
-            }
-            return true;
-          });
-          const repairedMessageIds = repairedMessages.map((message) => message.id);
-          setMessages(repairedMessages);
-          if ((_t = agentSessionRef.current) == null ? void 0 : _t.nodeName) {
-            setAgentSession({
-              threadId: agentSessionRef.current.threadId,
-              agentName: agentSessionRef.current.agentName,
-              nodeName: "__end__"
-            });
+      }
+    };
+    const { unsubscribe } = agent.subscribe(subscriber);
+    return () => {
+      unsubscribe();
+    };
+  }, [agent, threadId]);
+  const handleResolve = (0, import_react7.useCallback)(
+    (eventId, response) => {
+      agent == null ? void 0 : agent.runAgent({
+        forwardedProps: {
+          command: {
+            resume: response
           }
-          return newMessages.filter((message) => repairedMessageIds.includes(message.id));
-        } else {
-          return newMessages.slice();
         }
-      } finally {
-        setIsLoading(false);
-      }
-    }),
-    [
-      messages,
-      setMessages,
-      makeSystemMessageCallback,
-      copilotConfig,
-      setIsLoading,
-      initialMessages,
-      isLoading,
-      actions,
-      onFunctionCall,
-      onCoAgentStateRender,
-      setCoagentStatesWithRef,
-      coagentStatesRef,
-      agentSession,
-      setAgentSession,
-      disableSystemMessage,
-      context
-    ]
-  );
-  runChatCompletionRef.current = runChatCompletion;
-  const runChatCompletionAndHandleFunctionCall = useAsyncCallback(
-    (messages2) => __async(this, null, function* () {
-      yield runChatCompletionRef.current(messages2);
-    }),
-    [messages]
+      });
+      resolveInterruptEvent(threadId, eventId, response != null ? response : "");
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [agent, threadId]
   );
-  (0, import_react6.useEffect)(() => {
-    if (!isLoading && pendingAppendsRef.current.length > 0) {
-      const pending = pendingAppendsRef.current.splice(0);
-      const followUp = pending.some((p) => p.followUp);
-      const newMessages = [...messages, ...pending.map((p) => p.message)];
-      setMessages(newMessages);
-      if (followUp) {
-        runChatCompletionAndHandleFunctionCall(newMessages);
-      }
-    }
-  }, [isLoading, messages, setMessages, runChatCompletionAndHandleFunctionCall]);
-  const composeAndFlushMetaEventsInput = (0, import_react6.useCallback)(
-    (metaEvents) => {
-      return metaEvents.reduce((acc, event) => {
-        if (!event)
-          return acc;
-        switch (event.name) {
-          case import_runtime_client_gql3.MetaEventName.LangGraphInterruptEvent:
-            if (event.response) {
-              setLangGraphInterruptAction(threadId, null);
-              const value = event.value;
-              return [
-                ...acc,
-                {
-                  name: event.name,
-                  value: typeof value === "string" ? value : JSON.stringify(value),
-                  response: typeof event.response === "string" ? event.response : JSON.stringify(event.response)
-                }
-              ];
-            }
-            return acc;
-          default:
-            return acc;
-        }
-      }, []);
-    },
-    [setLangGraphInterruptAction]
-  );
-  const append = useAsyncCallback(
-    (message, options2) => __async(this, null, function* () {
-      var _a;
-      const followUp = (_a = options2 == null ? void 0 : options2.followUp) != null ? _a : true;
-      if (isLoading) {
-        pendingAppendsRef.current.push({ message, followUp });
-        return;
-      }
-      const newMessages = [...messages, message];
-      setMessages(newMessages);
-      if (followUp) {
-        return runChatCompletionAndHandleFunctionCall(newMessages);
-      }
-    }),
-    [isLoading, messages, setMessages, runChatCompletionAndHandleFunctionCall]
-  );
-  const reload = useAsyncCallback(
-    (reloadMessageId) => __async(this, null, function* () {
-      if (isLoading || messages.length === 0) {
-        return;
-      }
-      const reloadMessageIndex = messages.findIndex((msg) => msg.id === reloadMessageId);
-      if (reloadMessageIndex === -1) {
-        console.warn(`Message with id ${reloadMessageId} not found`);
-        return;
-      }
-      const reloadMessageRole = messages[reloadMessageIndex].role;
-      if (reloadMessageRole !== import_runtime_client_gql3.MessageRole.Assistant) {
-        console.warn(`Regenerate cannot be performed on ${reloadMessageRole} role`);
-        return;
-      }
-      let historyCutoff = [messages[0]];
-      if (messages.length > 2 && reloadMessageIndex !== 0) {
-        const lastUserMessageBeforeRegenerate = messages.slice(0, reloadMessageIndex).reverse().find(
-          (msg) => (
-            // @ts-expect-error -- message has role
-            msg.role === import_runtime_client_gql3.MessageRole.User
-          )
-        );
-        const indexOfLastUserMessageBeforeRegenerate = messages.findIndex(
-          (msg) => msg.id === lastUserMessageBeforeRegenerate.id
-        );
-        historyCutoff = messages.slice(0, indexOfLastUserMessageBeforeRegenerate + 1);
-      } else if (messages.length > 2 && reloadMessageIndex === 0) {
-        historyCutoff = [messages[0], messages[1]];
-      }
-      setMessages(historyCutoff);
-      return runChatCompletionAndHandleFunctionCall(historyCutoff);
-    }),
-    [isLoading, messages, setMessages, runChatCompletionAndHandleFunctionCall]
-  );
-  const stop = () => {
-    var _a;
-    (_a = chatAbortControllerRef.current) == null ? void 0 : _a.abort("Stop was called");
-  };
-  return {
-    append,
-    reload,
-    stop,
-    runChatCompletion: () => runChatCompletionRef.current(messages)
-  };
-}
-function constructFinalMessages(syncedMessages, previousMessages, newMessages) {
-  const finalMessages = syncedMessages.length > 0 ? [...syncedMessages] : [...previousMessages, ...newMessages];
-  if (syncedMessages.length > 0) {
-    const messagesWithAgentState = [...previousMessages, ...newMessages];
-    let previousMessageId = void 0;
-    for (const message of messagesWithAgentState) {
-      if (message.isAgentStateMessage()) {
-        const index = finalMessages.findIndex((msg) => msg.id === previousMessageId);
-        if (index !== -1) {
-          finalMessages.splice(index + 1, 0, message);
-        }
-      }
-      previousMessageId = message.id;
-    }
-  }
-  return finalMessages;
-}
-function executeAction(_0) {
-  return __async(this, arguments, function* ({
-    onFunctionCall,
-    message,
-    chatAbortControllerRef,
-    onError,
-    setMessages,
-    getFinalMessages,
-    isRenderAndWait
-  }) {
-    let result;
-    let error = null;
-    const currentMessagesForHandler = getFinalMessages();
-    const handlerReturnedPromise = onFunctionCall({
-      messages: currentMessagesForHandler,
-      name: message.name,
-      args: message.arguments
+  return (0, import_react7.useMemo)(() => {
+    const eventQueue = interruptEventQueue[threadId] || [];
+    const currentQueuedEvent = eventQueue.find((qe) => !qe.event.response);
+    if (!currentQueuedEvent || !agentSession)
+      return null;
+    const allActions = Object.values(interruptActions);
+    const matchingAction = allActions.find((action) => {
+      if (!action.enabled)
+        return true;
+      return action.enabled({
+        eventValue: currentQueuedEvent.event.value,
+        agentMetadata: __spreadProps(__spreadValues({}, agentSession), {
+          nodeName
+        })
+      });
     });
-    if (isRenderAndWait) {
-      const currentMessagesForRender = getFinalMessages();
-      (0, import_react_dom.flushSync)(() => {
-        setMessages([...currentMessagesForRender]);
+    if (!matchingAction)
+      return null;
+    const { render, handler } = matchingAction;
+    const resolveInterrupt = (response) => {
+      handleResolve(currentQueuedEvent.eventId, response);
+    };
+    let result = null;
+    if (handler) {
+      result = handler({
+        event: currentQueuedEvent.event,
+        resolve: resolveInterrupt
       });
     }
-    try {
-      result = yield Promise.race([
-        handlerReturnedPromise,
-        // Await the promise returned by the handler
-        new Promise(
-          (resolve) => {
-            var _a;
-            return (_a = chatAbortControllerRef.current) == null ? void 0 : _a.signal.addEventListener(
-              "abort",
-              () => resolve("Operation was aborted by the user")
-            );
-          }
-        ),
-        // if the user stopped generation, we also abort consecutive actions
-        new Promise((resolve) => {
-          var _a;
-          if ((_a = chatAbortControllerRef.current) == null ? void 0 : _a.signal.aborted) {
-            resolve("Operation was aborted by the user");
-          }
-        })
-      ]);
-    } catch (e) {
-      onError(e);
-    }
-    return new import_runtime_client_gql3.ResultMessage({
-      id: "result-" + message.id,
-      result: import_runtime_client_gql3.ResultMessage.encodeResult(
-        error ? {
-          content: result,
-          error: JSON.parse(JSON.stringify(error, Object.getOwnPropertyNames(error)))
-        } : result
-      ),
-      actionExecutionId: message.id,
-      actionName: message.name
+    if (!render)
+      return null;
+    return import_react7.default.createElement(InterruptRenderer, {
+      event: currentQueuedEvent.event,
+      result,
+      render,
+      resolve: resolveInterrupt
     });
-  });
+  }, [interruptActions, interruptEventQueue, threadId, agentSession, handleResolve]);
 }
-function getPairedFeAction(actions, message) {
-  let actionName = null;
-  if (message.isActionExecutionMessage()) {
-    actionName = message.name;
-  } else if (message.isResultMessage()) {
-    actionName = message.actionName;
-  }
-  return actions.find(
-    (action) => action.name === actionName && action.available === "frontend" || action.pairedAction === actionName
+
+// src/hooks/use-copilot-chat_internal.ts
+var import_react14 = require("@copilotkitnext/react");
+
+// src/hooks/use-lazy-tool-renderer.tsx
+var import_react9 = require("@copilotkitnext/react");
+var import_react10 = require("react");
+function useLazyToolRenderer() {
+  const renderToolCall = (0, import_react9.useRenderToolCall)();
+  return (0, import_react10.useCallback)(
+    (message, messages) => {
+      var _a;
+      if (!((_a = message == null ? void 0 : message.toolCalls) == null ? void 0 : _a.length))
+        return null;
+      const toolCall = message.toolCalls[0];
+      if (!toolCall)
+        return null;
+      const toolMessage = messages == null ? void 0 : messages.find(
+        (m) => m.role === "tool" && m.toolCallId === toolCall.id
+      );
+      return () => renderToolCall({
+        toolCall,
+        toolMessage
+      });
+    },
+    [renderToolCall]
   );
 }
 
-// src/components/copilot-provider/copilotkit.tsx
-var import_react8 = require("react");
-var import_react_dom2 = require("react-dom");
-var import_shared8 = require("@copilotkit/shared");
+// src/hooks/use-copilot-chat_internal.ts
+var import_client = require("@ag-ui/client");
 
-// src/components/copilot-provider/copilot-messages.tsx
-var import_react7 = require("react");
-var import_runtime_client_gql4 = require("@copilotkit/runtime-client-gql");
-var import_shared5 = require("@copilotkit/shared");
-var import_jsx_runtime4 = require("react/jsx-runtime");
-var MessagesTapContext = (0, import_react7.createContext)(null);
-function useMessagesTap() {
-  const tap = (0, import_react7.useContext)(MessagesTapContext);
-  if (!tap)
-    throw new Error("useMessagesTap must be used inside <MessagesTapProvider>");
-  return tap;
+// src/hooks/use-coagent-state-render-bridge.tsx
+var import_react11 = require("@copilotkitnext/react");
+var import_react12 = require("react");
+var import_shared3 = require("@copilotkit/shared");
+function getStateWithoutConstantKeys(state) {
+  if (!state)
+    return {};
+  const _a = state, { messages, tools, copilotkit } = _a, stateWithoutConstantKeys = __objRest(_a, ["messages", "tools", "copilotkit"]);
+  return stateWithoutConstantKeys;
 }
-
-// src/utils/extract.ts
-var import_shared6 = require("@copilotkit/shared");
-var import_runtime_client_gql5 = require("@copilotkit/runtime-client-gql");
-var import_runtime_client_gql6 = require("@copilotkit/runtime-client-gql");
-function extract(_0) {
-  return __async(this, arguments, function* ({
-    context,
-    instructions,
-    parameters,
-    include,
-    data,
-    abortSignal,
-    stream,
-    requestType = import_runtime_client_gql5.CopilotRequestType.Task,
-    forwardedParameters
-  }) {
-    var _a, _b;
-    const { messages } = context;
-    const action = {
-      name: "extract",
-      description: instructions,
-      parameters,
-      handler: (args) => {
+function areStatesEquals(a, b) {
+  if (a && !b || !a && b)
+    return false;
+  const _a = a, { messages, tools, copilotkit } = _a, aWithoutConstantKeys = __objRest(_a, ["messages", "tools", "copilotkit"]);
+  const _b = b, {
+    messages: bMessages,
+    tools: bTools,
+    copilotkit: bCopilotkit
+  } = _b, bWithoutConstantKeys = __objRest(_b, [
+    "messages",
+    "tools",
+    "copilotkit"
+  ]);
+  return JSON.stringify(aWithoutConstantKeys) === JSON.stringify(bWithoutConstantKeys);
+}
+function useCoagentStateRenderBridge(agentId, props) {
+  var _a;
+  const { stateSnapshot, messageIndexInRun, message } = props;
+  const { coAgentStateRenders, claimsRef } = useCoAgentStateRenders();
+  const { agent } = (0, import_react11.useAgent)({ agentId });
+  const [nodeName, setNodeName] = (0, import_react12.useState)(void 0);
+  const runId = (_a = props.runId) != null ? _a : message.runId;
+  const effectiveRunId = runId || "pending";
+  (0, import_react12.useEffect)(() => {
+    if (!agent)
+      return;
+    const subscriber = {
+      onStepStartedEvent: ({ event }) => {
+        if (event.stepName !== nodeName) {
+          setNodeName(event.stepName);
+        }
+      },
+      onStepFinishedEvent: ({ event }) => {
+        if (event.stepName === nodeName) {
+          setNodeName(void 0);
+        }
       }
     };
-    const includeReadable = (_a = include == null ? void 0 : include.readable) != null ? _a : false;
-    const includeMessages = (_b = include == null ? void 0 : include.messages) != null ? _b : false;
-    let contextString = "";
-    if (data) {
-      contextString = (typeof data === "string" ? data : JSON.stringify(data)) + "\n\n";
-    }
-    if (includeReadable) {
-      contextString += context.getContextString([], defaultCopilotContextCategories);
+    const { unsubscribe } = agent.subscribe(subscriber);
+    return () => {
+      unsubscribe();
+    };
+  }, [agentId, nodeName]);
+  const getStateRender = (0, import_react12.useCallback)(
+    (messageId) => {
+      return Object.entries(coAgentStateRenders).find(([stateRenderId, stateRender]) => {
+        if (claimsRef.current[messageId]) {
+          return stateRenderId === claimsRef.current[messageId].stateRenderId;
+        }
+        const matchingAgentName = stateRender.name === agentId;
+        const matchesNodeContext = stateRender.nodeName ? stateRender.nodeName === nodeName : true;
+        return matchingAgentName && matchesNodeContext;
+      });
+    },
+    [coAgentStateRenders, nodeName, agentId]
+  );
+  const handleRenderRequest = ({
+    stateRenderId,
+    messageId,
+    runId: runId2,
+    stateSnapshot: renderSnapshot
+  }) => {
+    if (claimsRef.current[messageId]) {
+      const canRender = claimsRef.current[messageId].stateRenderId === stateRenderId;
+      if (canRender && runId2 && (!claimsRef.current[messageId].runId || claimsRef.current[messageId].runId === "pending")) {
+        claimsRef.current[messageId].runId = runId2;
+      }
+      return canRender;
     }
-    const systemMessage = new import_runtime_client_gql5.TextMessage({
-      content: makeSystemMessage(contextString, instructions),
-      role: import_runtime_client_gql5.Role.System
-    });
-    const instructionsMessage = new import_runtime_client_gql5.TextMessage({
-      content: makeInstructionsMessage(instructions),
-      role: import_runtime_client_gql5.Role.User
-    });
-    const response = context.runtimeClient.asStream(
-      context.runtimeClient.generateCopilotResponse({
-        data: {
-          frontend: {
-            actions: [
-              {
-                name: action.name,
-                description: action.description || "",
-                jsonSchema: JSON.stringify((0, import_shared6.actionParametersToJsonSchema)(action.parameters || []))
-              }
-            ],
-            url: window.location.href
-          },
-          messages: (0, import_runtime_client_gql6.convertMessagesToGqlInput)(
-            includeMessages ? [systemMessage, instructionsMessage, ...(0, import_runtime_client_gql6.filterAgentStateMessages)(messages)] : [systemMessage, instructionsMessage]
-          ),
-          metadata: {
-            requestType
-          },
-          forwardedParameters: __spreadProps(__spreadValues({}, forwardedParameters != null ? forwardedParameters : {}), {
-            toolChoice: "function",
-            toolChoiceFunctionName: action.name
-          })
-        },
-        properties: context.copilotApiConfig.properties,
-        signal: abortSignal
-      })
+    const renderClaimedByOtherMessage = Object.values(claimsRef.current).find(
+      (c) => c.stateRenderId === stateRenderId && (0, import_shared3.dataToUUID)(getStateWithoutConstantKeys(c.stateSnapshot)) === (0, import_shared3.dataToUUID)(getStateWithoutConstantKeys(renderSnapshot))
     );
-    const reader = response.getReader();
-    let isInitial = true;
-    let actionExecutionMessage = void 0;
-    while (true) {
-      const { done, value } = yield reader.read();
-      if (done) {
-        break;
-      }
-      if (abortSignal == null ? void 0 : abortSignal.aborted) {
-        throw new Error("Aborted");
+    if (renderClaimedByOtherMessage) {
+      if (renderSnapshot && renderClaimedByOtherMessage.stateSnapshot && !areStatesEquals(renderClaimedByOtherMessage.stateSnapshot, renderSnapshot)) {
+        claimsRef.current[messageId] = { stateRenderId, runId: runId2 };
+        return true;
       }
-      actionExecutionMessage = (0, import_runtime_client_gql5.convertGqlOutputToMessages)(
-        value.generateCopilotResponse.messages
-      ).find((msg) => msg.isActionExecutionMessage());
-      if (!actionExecutionMessage) {
-        continue;
+      return false;
+    }
+    if (!runId2) {
+      return false;
+    }
+    claimsRef.current[messageId] = { stateRenderId, runId: runId2 };
+    return true;
+  };
+  return (0, import_react12.useMemo)(() => {
+    var _a2, _b, _c;
+    if (messageIndexInRun !== 0) {
+      return null;
+    }
+    const [stateRenderId, stateRender] = (_a2 = getStateRender(message.id)) != null ? _a2 : [];
+    if (!stateRender || !stateRenderId) {
+      return null;
+    }
+    const snapshot = stateSnapshot ? (0, import_shared3.parseJson)(stateSnapshot, stateSnapshot) : agent == null ? void 0 : agent.state;
+    const canRender = handleRenderRequest({
+      stateRenderId,
+      messageId: message.id,
+      runId: effectiveRunId,
+      stateSnapshot: snapshot
+    });
+    if (!canRender) {
+      return null;
+    }
+    if (snapshot && !claimsRef.current[message.id].locked) {
+      if (stateSnapshot) {
+        claimsRef.current[message.id].stateSnapshot = snapshot;
+        claimsRef.current[message.id].locked = true;
+      } else {
+        claimsRef.current[message.id].stateSnapshot = snapshot;
       }
-      stream == null ? void 0 : stream({
-        status: isInitial ? "initial" : "inProgress",
-        args: actionExecutionMessage.arguments
+    }
+    if (stateRender.handler) {
+      stateRender.handler({
+        state: stateSnapshot ? (0, import_shared3.parseJson)(stateSnapshot, stateSnapshot) : (_b = agent == null ? void 0 : agent.state) != null ? _b : {},
+        nodeName: nodeName != null ? nodeName : ""
       });
-      isInitial = false;
     }
-    if (!actionExecutionMessage) {
-      throw new Error("extract() failed: No function call occurred");
+    if (stateRender.render) {
+      const status = (agent == null ? void 0 : agent.isRunning) ? "inProgress" : "complete";
+      if (typeof stateRender.render === "string")
+        return stateRender.render;
+      return stateRender.render({
+        status,
+        // Always use state from claim, to make sure the state does not seem "wiped" for a fraction of a second
+        state: (_c = claimsRef.current[message.id].stateSnapshot) != null ? _c : {},
+        nodeName: nodeName != null ? nodeName : ""
+      });
     }
-    stream == null ? void 0 : stream({
-      status: "complete",
-      args: actionExecutionMessage.arguments
-    });
-    return actionExecutionMessage.arguments;
-  });
-}
-function makeInstructionsMessage(instructions) {
-  return `
-The user has given you the following task to complete:
-
-\`\`\`
-${instructions}
-\`\`\`
-
-Any additional messages provided are for providing context only and should not be used to ask questions or engage in conversation.
-`;
+  }, [
+    getStateRender,
+    stateSnapshot,
+    agent == null ? void 0 : agent.state,
+    agent == null ? void 0 : agent.isRunning,
+    nodeName,
+    effectiveRunId,
+    message.id,
+    messageIndexInRun
+  ]);
 }
-function makeSystemMessage(contextString, instructions) {
-  return `
-Please act as an efficient, competent, conscientious, and industrious professional assistant.
-
-Help the user achieve their goals, and you do so in a way that is as efficient as possible, without unnecessary fluff, but also without sacrificing professionalism.
-Always be polite and respectful, and prefer brevity over verbosity.
-
-The user has provided you with the following context:
-\`\`\`
-${contextString}
-\`\`\`
-
-They have also provided you with a function called extract you MUST call to initiate actions on their behalf.
-
-Please assist them as best you can.
-
-This is not a conversation, so please do not ask questions. Just call the function without saying anything else.
-`;
+function CoAgentStateRenderBridge(props) {
+  return useCoagentStateRenderBridge(props.agentId, props);
 }
 
-// src/utils/suggestions.ts
-var import_shared7 = require("@copilotkit/shared");
-var import_runtime_client_gql7 = require("@copilotkit/runtime-client-gql");
-var reloadSuggestions = (context, chatSuggestionConfiguration, setCurrentSuggestions, abortControllerRef) => __async(void 0, null, function* () {
-  const abortController = abortControllerRef.current;
-  if (abortController == null ? void 0 : abortController.signal.aborted) {
-    return;
-  }
-  const setSuggestionsIfNotAborted = (suggestions) => {
-    if (!(abortController == null ? void 0 : abortController.signal.aborted) && abortControllerRef.current === abortController) {
-      setCurrentSuggestions(suggestions);
-    }
-  };
-  try {
-    const tools = JSON.stringify(
-      Object.values(context.actions).map((action) => ({
-        name: action.name,
-        description: action.description,
-        jsonSchema: JSON.stringify((0, import_shared7.actionParametersToJsonSchema)(action.parameters))
-      }))
-    );
-    const allSuggestions = [];
-    let hasSuccessfulSuggestions = false;
-    let hasErrors = false;
-    let lastError = null;
-    const enabledConfigs = Object.values(chatSuggestionConfiguration).filter(
-      (config) => config.instructions && config.instructions.trim().length > 0
-    );
-    if (enabledConfigs.length === 0) {
-      return;
-    }
-    setSuggestionsIfNotAborted([]);
-    for (const config of enabledConfigs) {
-      if (abortController == null ? void 0 : abortController.signal.aborted) {
-        setSuggestionsIfNotAborted([]);
-        return;
-      }
+// src/hooks/use-copilot-chat_internal.ts
+function useCopilotChatInternal({
+  suggestions,
+  onInProgress,
+  onSubmitMessage,
+  onStopGeneration,
+  onReloadMessages
+} = {}) {
+  var _a, _b, _c;
+  const { copilotkit } = (0, import_react14.useCopilotKit)();
+  const { threadId, agentSession } = useCopilotContext();
+  const existingConfig = (0, import_react14.useCopilotChatConfiguration)();
+  const [agentAvailable, setAgentAvailable] = (0, import_react13.useState)(false);
+  const resolvedAgentId = (_a = existingConfig == null ? void 0 : existingConfig.agentId) != null ? _a : "default";
+  const { agent } = (0, import_react14.useAgent)({ agentId: resolvedAgentId });
+  (0, import_react13.useEffect)(() => {
+    const connect = (agent2) => __async(this, null, function* () {
+      setAgentAvailable(false);
       try {
-        const result = yield extract({
-          context,
-          instructions: "Suggest what the user could say next. Provide clear, highly relevant suggestions. Do not literally suggest function calls. ",
-          data: `${config.instructions}
-
-Available tools: ${tools}
-
-`,
-          requestType: import_runtime_client_gql7.CopilotRequestType.Task,
-          parameters: [
-            {
-              name: "suggestions",
-              type: "object[]",
-              attributes: [
-                {
-                  name: "title",
-                  description: "The title of the suggestion. This is shown as a button and should be short.",
-                  type: "string"
-                },
-                {
-                  name: "message",
-                  description: "The message to send when the suggestion is clicked. This should be a clear, complete sentence and will be sent as an instruction to the AI.",
-                  type: "string"
-                }
-              ]
-            }
-          ],
-          include: {
-            messages: true,
-            readable: true
-          },
-          abortSignal: abortController == null ? void 0 : abortController.signal,
-          stream: ({ status, args }) => {
-            if (abortController == null ? void 0 : abortController.signal.aborted) {
-              return;
-            }
-            const suggestions = args.suggestions || [];
-            const newSuggestions = [];
-            for (let i = 0; i < suggestions.length; i++) {
-              if (config.maxSuggestions !== void 0 && i >= config.maxSuggestions) {
-                break;
-              }
-              const suggestion = suggestions[i];
-              if (!suggestion || typeof suggestion !== "object") {
-                continue;
-              }
-              const { title, message } = suggestion;
-              const hasValidTitle = title && typeof title === "string" && title.trim().length > 0;
-              const hasValidMessage = message && typeof message === "string" && message.trim().length > 0;
-              if (!hasValidTitle) {
-                continue;
-              }
-              const partial = i === suggestions.length - 1 && status !== "complete";
-              newSuggestions.push({
-                title: title.trim(),
-                message: hasValidMessage ? message.trim() : "",
-                // Use title as fallback
-                partial,
-                className: config.className
-              });
-            }
-            setSuggestionsIfNotAborted([...allSuggestions, ...newSuggestions]);
-          }
-        });
-        if ((result == null ? void 0 : result.suggestions) && Array.isArray(result.suggestions)) {
-          const validSuggestions = result.suggestions.filter(
-            (suggestion) => suggestion && typeof suggestion.title === "string" && suggestion.title.trim().length > 0
-          ).map((suggestion) => ({
-            title: suggestion.title.trim(),
-            message: suggestion.message && typeof suggestion.message === "string" && suggestion.message.trim() ? suggestion.message.trim() : suggestion.title.trim()
-          }));
-          if (validSuggestions.length > 0) {
-            allSuggestions.push(...validSuggestions);
-            hasSuccessfulSuggestions = true;
-          }
-        }
+        yield copilotkit.connectAgent({ agent: agent2 });
+        setAgentAvailable(true);
       } catch (error) {
-        hasErrors = true;
-        lastError = error instanceof Error ? error : new Error(String(error));
+        if (error instanceof import_client.AGUIConnectNotImplementedError) {
+        } else {
+          throw error;
+        }
       }
+    });
+    if (agent && (existingConfig == null ? void 0 : existingConfig.threadId) && agent.threadId !== existingConfig.threadId) {
+      agent.threadId = existingConfig.threadId;
+      connect(agent);
     }
-    if (hasSuccessfulSuggestions && allSuggestions.length > 0) {
-      const uniqueSuggestions = allSuggestions.filter(
-        (suggestion, index, self) => index === self.findIndex((s) => s.message === suggestion.message)
+    return () => {
+    };
+  }, [existingConfig == null ? void 0 : existingConfig.threadId, agent, copilotkit, resolvedAgentId]);
+  (0, import_react13.useEffect)(() => {
+    onInProgress == null ? void 0 : onInProgress(Boolean(agent == null ? void 0 : agent.isRunning));
+  }, [agent == null ? void 0 : agent.isRunning, onInProgress]);
+  const interrupt = useLangGraphInterruptRender(agent);
+  const reset = () => {
+    agent == null ? void 0 : agent.setMessages([]);
+    agent == null ? void 0 : agent.setState(null);
+  };
+  const deleteMessage = (0, import_react13.useCallback)(
+    (messageId) => {
+      var _a2;
+      const filteredMessages = ((_a2 = agent == null ? void 0 : agent.messages) != null ? _a2 : []).filter(
+        (message) => message.id !== messageId
       );
-      setSuggestionsIfNotAborted(uniqueSuggestions);
-    } else if (hasErrors) {
-      const errorMessage = lastError ? lastError.message : "Failed to generate suggestions due to API errors";
-      throw new Error(errorMessage);
-    }
-  } catch (error) {
-    throw error;
-  }
-});
-
-// src/components/copilot-provider/copilotkit.tsx
-var import_jsx_runtime5 = require("react/jsx-runtime");
-var defaultCopilotContextCategories = ["global"];
-
-// src/hooks/use-copilot-chat_internal.ts
-var import_runtime_client_gql8 = require("@copilotkit/runtime-client-gql");
-
-// src/hooks/use-langgraph-interrupt-render.ts
-var import_react9 = __toESM(require("react"));
-var InterruptRenderer = ({ event, result, render, resolve }) => {
-  return render({ event, result, resolve });
-};
-function useLangGraphInterruptRender() {
-  const { langGraphInterruptAction, setLangGraphInterruptAction, agentSession, threadId } = useCopilotContext();
-  const responseRef = import_react9.default.useRef();
-  const resolveInterrupt = (0, import_react9.useCallback)(
-    (response) => {
-      responseRef.current = response;
-      setTimeout(() => {
-        setLangGraphInterruptAction(threadId, { event: { response } });
-      }, 0);
+      agent == null ? void 0 : agent.setMessages(filteredMessages);
     },
-    [setLangGraphInterruptAction, threadId]
+    [agent == null ? void 0 : agent.setMessages, agent == null ? void 0 : agent.messages]
   );
-  if (!langGraphInterruptAction || !langGraphInterruptAction.event || !langGraphInterruptAction.render)
-    return null;
-  const { render, handler, event, enabled } = langGraphInterruptAction;
-  const conditionsMet = !agentSession || !enabled ? true : enabled({ eventValue: event.value, agentMetadata: agentSession });
-  if (!conditionsMet) {
-    return null;
-  }
-  let result = null;
-  if (handler) {
-    result = handler({
-      event,
-      resolve: resolveInterrupt
-    });
-  }
-  return import_react9.default.createElement(InterruptRenderer, {
-    event,
-    result,
-    render,
-    resolve: resolveInterrupt
-  });
-}
-
-// src/hooks/use-copilot-chat_internal.ts
-var globalSuggestionPromise = null;
-function useCopilotChat(options = {}) {
-  var _a;
-  const makeSystemMessage2 = (_a = options.makeSystemMessage) != null ? _a : defaultSystemMessage;
-  const {
-    getContextString,
-    getFunctionCallHandler,
-    copilotApiConfig,
-    isLoading,
-    setIsLoading,
-    chatInstructions,
-    actions,
-    coagentStatesRef,
-    setCoagentStatesWithRef,
-    coAgentStateRenders,
-    agentSession,
-    setAgentSession,
-    forwardedParameters,
-    agentLock,
-    threadId,
-    setThreadId,
-    runId,
-    setRunId,
-    chatAbortControllerRef,
-    extensions,
-    setExtensions,
-    langGraphInterruptAction,
-    setLangGraphInterruptAction,
-    chatSuggestionConfiguration,
-    runtimeClient
-  } = useCopilotContext();
-  const { messages, setMessages, suggestions, setSuggestions } = useCopilotMessagesContext();
-  const [mcpServers, setLocalMcpServers] = (0, import_react10.useState)([]);
-  const suggestionsAbortControllerRef = (0, import_react10.useRef)(null);
-  const isLoadingSuggestionsRef = (0, import_react10.useRef)(false);
-  const abortSuggestions = (0, import_react10.useCallback)(
-    (clear = true) => {
-      var _a2;
-      (_a2 = suggestionsAbortControllerRef.current) == null ? void 0 : _a2.abort("suggestions aborted by user");
-      suggestionsAbortControllerRef.current = null;
-      if (clear) {
-        setSuggestions([]);
-      }
+  const latestDelete = useUpdatedRef(deleteMessage);
+  const latestDeleteFunc = (0, import_react13.useCallback)(
+    (messageId) => {
+      return latestDelete.current(messageId);
     },
-    [setSuggestions]
+    [latestDelete]
   );
-  const stableContext = (0, import_react10.useMemo)(() => {
-    return {
-      actions,
-      copilotApiConfig,
-      chatSuggestionConfiguration,
-      messages,
-      setMessages,
-      getContextString,
-      runtimeClient
-    };
-  }, [
-    JSON.stringify(Object.keys(actions)),
-    copilotApiConfig.chatApiEndpoint,
-    messages.length,
-    Object.keys(chatSuggestionConfiguration).length
-  ]);
-  const generateSuggestionsFunc = (0, import_react10.useCallback)(() => __async(this, null, function* () {
-    if (globalSuggestionPromise) {
-      return globalSuggestionPromise;
-    }
-    globalSuggestionPromise = (() => __async(this, null, function* () {
-      try {
-        abortSuggestions();
-        isLoadingSuggestionsRef.current = true;
-        suggestionsAbortControllerRef.current = new AbortController();
-        setSuggestions([]);
-        yield reloadSuggestions(
-          stableContext,
-          chatSuggestionConfiguration,
-          setSuggestions,
-          suggestionsAbortControllerRef
-        );
-      } catch (error) {
-        throw error;
-      } finally {
-        isLoadingSuggestionsRef.current = false;
-        globalSuggestionPromise = null;
+  const currentSuggestions = (0, import_react14.useSuggestions)({ agentId: resolvedAgentId });
+  const reload = useAsyncCallback(
+    (reloadMessageId) => __async(this, null, function* () {
+      var _a2;
+      const messages = (_a2 = agent == null ? void 0 : agent.messages) != null ? _a2 : [];
+      const isLoading = false;
+      if (isLoading || messages.length === 0) {
+        return;
       }
-    }))();
-    return globalSuggestionPromise;
-  }), [stableContext, chatSuggestionConfiguration, setSuggestions, abortSuggestions]);
-  const resetSuggestions = (0, import_react10.useCallback)(() => {
-    setSuggestions([]);
-  }, [setSuggestions]);
-  (0, import_react10.useEffect)(() => {
-    if (mcpServers.length > 0) {
-      const serversCopy = [...mcpServers];
-      copilotApiConfig.mcpServers = serversCopy;
-      if (!copilotApiConfig.properties) {
-        copilotApiConfig.properties = {};
+      const reloadMessageIndex = messages.findIndex((msg) => msg.id === reloadMessageId);
+      if (reloadMessageIndex === -1) {
+        console.warn(`Message with id ${reloadMessageId} not found`);
+        return;
       }
-      copilotApiConfig.properties.mcpServers = serversCopy;
-    }
-  }, [mcpServers, copilotApiConfig]);
-  const setMcpServers = (0, import_react10.useCallback)((servers) => {
-    setLocalMcpServers(servers);
-  }, []);
-  const onCoAgentStateRender = useAsyncCallback(
-    (args) => __async(this, null, function* () {
-      var _a2;
-      const { name, nodeName, state } = args;
-      let action = Object.values(coAgentStateRenders).find(
-        (action2) => action2.name === name && action2.nodeName === nodeName
-      );
-      if (!action) {
-        action = Object.values(coAgentStateRenders).find(
-          (action2) => action2.name === name && !action2.nodeName
-        );
+      const reloadMessageRole = messages[reloadMessageIndex].role;
+      if (reloadMessageRole !== "assistant") {
+        console.warn(`Regenerate cannot be performed on ${reloadMessageRole} role`);
+        return;
       }
-      if (action) {
-        yield (_a2 = action.handler) == null ? void 0 : _a2.call(action, { state, nodeName });
+      let historyCutoff = [messages[0]];
+      if (messages.length > 2 && reloadMessageIndex !== 0) {
+        const lastUserMessageBeforeRegenerate = messages.slice(0, reloadMessageIndex).reverse().find((msg) => msg.role === "user");
+        if (!lastUserMessageBeforeRegenerate) {
+          historyCutoff = [messages[0]];
+        } else {
+          const indexOfLastUserMessageBeforeRegenerate = messages.findIndex(
+            (msg) => msg.id === lastUserMessageBeforeRegenerate.id
+          );
+          historyCutoff = messages.slice(0, indexOfLastUserMessageBeforeRegenerate + 1);
+        }
+      } else if (messages.length > 2 && reloadMessageIndex === 0) {
+        historyCutoff = [messages[0], messages[1]];
       }
+      agent == null ? void 0 : agent.setMessages(historyCutoff);
+      if (agent) {
+        copilotkit.runAgent({ agent });
+      }
+      return;
     }),
-    [coAgentStateRenders]
+    [agent == null ? void 0 : agent.setMessages, copilotkit == null ? void 0 : copilotkit.runAgent]
   );
-  const makeSystemMessageCallback = (0, import_react10.useCallback)(() => {
-    const systemMessageMaker = makeSystemMessage2 || defaultSystemMessage;
-    const contextString = getContextString([], defaultCopilotContextCategories);
-    return new import_runtime_client_gql8.TextMessage({
-      content: systemMessageMaker(contextString, chatInstructions),
-      role: import_runtime_client_gql8.Role.System
-    });
-  }, [getContextString, makeSystemMessage2, chatInstructions]);
-  const deleteMessage = (0, import_react10.useCallback)(
-    (messageId) => {
-      setMessages((prev) => prev.filter((message) => message.id !== messageId));
-    },
-    [setMessages]
+  const latestSendMessageFunc = useAsyncCallback(
+    (message, options) => __async(this, null, function* () {
+      var _a2;
+      if (!agent)
+        return;
+      const followUp = (_a2 = options == null ? void 0 : options.followUp) != null ? _a2 : true;
+      if (options == null ? void 0 : options.clearSuggestions) {
+        copilotkit.clearSuggestions(resolvedAgentId);
+      }
+      agent == null ? void 0 : agent.addMessage(message);
+      if (followUp) {
+        try {
+          yield copilotkit.runAgent({ agent });
+        } catch (error) {
+          console.error("CopilotChat: runAgent failed", error);
+        }
+      }
+      if (onSubmitMessage) {
+        const content = typeof message.content === "string" ? message.content : message.content && "text" in message.content ? message.content.text : message.content && "filename" in message.content ? message.content.filename : "";
+        onSubmitMessage(content);
+      }
+    }),
+    [agent, copilotkit, resolvedAgentId, onSubmitMessage]
   );
-  const { append, reload, stop, runChatCompletion } = useChat(__spreadProps(__spreadValues({}, options), {
-    actions: Object.values(actions),
-    copilotConfig: copilotApiConfig,
-    initialMessages: (0, import_runtime_client_gql8.aguiToGQL)(options.initialMessages || []),
-    onFunctionCall: getFunctionCallHandler(),
-    onCoAgentStateRender,
-    messages,
-    setMessages,
-    makeSystemMessageCallback,
-    isLoading,
-    setIsLoading,
-    coagentStatesRef,
-    setCoagentStatesWithRef,
-    agentSession,
-    setAgentSession,
-    forwardedParameters,
-    threadId,
-    setThreadId,
-    runId,
-    setRunId,
-    chatAbortControllerRef,
-    agentLock,
-    extensions,
-    setExtensions,
-    langGraphInterruptAction,
-    setLangGraphInterruptAction,
-    disableSystemMessage: options.disableSystemMessage
-  }));
-  const latestAppend = useUpdatedRef(append);
   const latestAppendFunc = useAsyncCallback(
-    (message, options2) => __async(this, null, function* () {
-      abortSuggestions(options2 == null ? void 0 : options2.clearSuggestions);
-      return yield latestAppend.current(message, options2);
+    (message, options) => __async(this, null, function* () {
+      return latestSendMessageFunc((0, import_runtime_client_gql2.gqlToAGUI)([message])[0], options);
     }),
-    [latestAppend]
+    [latestSendMessageFunc]
   );
-  const latestSendMessageFunc = useAsyncCallback(
-    (message, options2) => __async(this, null, function* () {
-      abortSuggestions(options2 == null ? void 0 : options2.clearSuggestions);
-      return yield latestAppend.current((0, import_runtime_client_gql8.aguiToGQL)([message])[0], options2);
-    }),
-    [latestAppend]
+  const latestSetMessagesFunc = (0, import_react13.useCallback)(
+    (messages) => {
+      var _a2, _b2;
+      if (messages.every((message) => message instanceof import_runtime_client_gql2.Message)) {
+        return (_a2 = agent == null ? void 0 : agent.setMessages) == null ? void 0 : _a2.call(agent, (0, import_runtime_client_gql2.gqlToAGUI)(messages));
+      }
+      return (_b2 = agent == null ? void 0 : agent.setMessages) == null ? void 0 : _b2.call(agent, messages);
+    },
+    [agent == null ? void 0 : agent.setMessages, agent]
   );
   const latestReload = useUpdatedRef(reload);
   const latestReloadFunc = useAsyncCallback(
     (messageId) => __async(this, null, function* () {
+      var _a2;
+      onReloadMessages == null ? void 0 : onReloadMessages({
+        messageId,
+        currentAgentName: agent == null ? void 0 : agent.agentId,
+        messages: (_a2 = agent == null ? void 0 : agent.messages) != null ? _a2 : []
+      });
       return yield latestReload.current(messageId);
     }),
-    [latestReload]
+    [latestReload, agent, onReloadMessages]
   );
-  const latestStop = useUpdatedRef(stop);
-  const latestStopFunc = (0, import_react10.useCallback)(() => {
-    return latestStop.current();
-  }, [latestStop]);
-  const latestDelete = useUpdatedRef(deleteMessage);
-  const latestDeleteFunc = (0, import_react10.useCallback)(
-    (messageId) => {
-      return latestDelete.current(messageId);
-    },
-    [latestDelete]
-  );
-  const latestSetMessages = useUpdatedRef(setMessages);
-  const latestSetMessagesFunc = (0, import_react10.useCallback)(
-    (messages2) => {
-      if (messages2.every((message) => message instanceof import_runtime_client_gql8.Message)) {
-        return latestSetMessages.current(messages2);
-      }
-      return latestSetMessages.current((0, import_runtime_client_gql8.aguiToGQL)(messages2));
-    },
-    [latestSetMessages]
-  );
-  const latestRunChatCompletion = useUpdatedRef(runChatCompletion);
-  const latestRunChatCompletionFunc = useAsyncCallback(() => __async(this, null, function* () {
-    return yield latestRunChatCompletion.current();
-  }), [latestRunChatCompletion]);
-  const reset = (0, import_react10.useCallback)(() => {
-    latestStopFunc();
-    setMessages([]);
-    setRunId(null);
-    setCoagentStatesWithRef({});
-    let initialAgentSession = null;
-    if (agentLock) {
-      initialAgentSession = {
-        agentName: agentLock
-      };
-    }
-    setAgentSession(initialAgentSession);
-    resetSuggestions();
-  }, [
-    latestStopFunc,
-    setMessages,
-    setThreadId,
-    setCoagentStatesWithRef,
-    setAgentSession,
-    agentLock,
-    resetSuggestions
-  ]);
+  const latestStopFunc = (0, import_react13.useCallback)(() => {
+    var _a2, _b2;
+    onStopGeneration == null ? void 0 : onStopGeneration({
+      currentAgentName: agent == null ? void 0 : agent.agentId,
+      messages: (_a2 = agent == null ? void 0 : agent.messages) != null ? _a2 : []
+    });
+    return (_b2 = agent == null ? void 0 : agent.abortRun) == null ? void 0 : _b2.call(agent);
+  }, [onStopGeneration, agent]);
   const latestReset = useUpdatedRef(reset);
-  const latestResetFunc = (0, import_react10.useCallback)(() => {
+  const latestResetFunc = (0, import_react13.useCallback)(() => {
     return latestReset.current();
   }, [latestReset]);
-  const interrupt = useLangGraphInterruptRender();
+  const lazyToolRendered = useLazyToolRenderer();
+  const renderCustomMessage = (0, import_react14.useRenderCustomMessages)();
+  const legacyCustomMessageRenderer = useLegacyCoagentRenderer({
+    copilotkit,
+    agent,
+    agentId: resolvedAgentId,
+    threadId: (_b = existingConfig == null ? void 0 : existingConfig.threadId) != null ? _b : threadId
+  });
+  const allMessages = (_c = agent == null ? void 0 : agent.messages) != null ? _c : [];
+  const resolvedMessages = (0, import_react13.useMemo)(() => {
+    let processedMessages = allMessages.map((message) => {
+      if (message.role !== "assistant") {
+        return message;
+      }
+      const lazyRendered = lazyToolRendered(message, allMessages);
+      if (lazyRendered) {
+        const renderedGenUi = lazyRendered();
+        if (renderedGenUi) {
+          return __spreadProps(__spreadValues({}, message), { generativeUI: () => renderedGenUi });
+        }
+      }
+      const bridgeRenderer = legacyCustomMessageRenderer || renderCustomMessage ? () => {
+        const customRender = renderCustomMessage == null ? void 0 : renderCustomMessage({
+          message,
+          position: "before"
+        });
+        if (customRender) {
+          return customRender;
+        }
+        return legacyCustomMessageRenderer == null ? void 0 : legacyCustomMessageRenderer({ message, position: "before" });
+      } : null;
+      if (bridgeRenderer) {
+        return __spreadProps(__spreadValues({}, message), { generativeUI: bridgeRenderer });
+      }
+      return message;
+    });
+    const hasAssistantMessages = processedMessages.some((msg) => msg.role === "assistant");
+    return processedMessages;
+  }, [
+    agent == null ? void 0 : agent.messages,
+    lazyToolRendered,
+    allMessages,
+    renderCustomMessage,
+    // legacyCustomMessageRenderer,
+    resolvedAgentId
+  ]);
+  const renderedSuggestions = (0, import_react13.useMemo)(() => {
+    if (Array.isArray(suggestions)) {
+      return {
+        suggestions: suggestions.map((s) => __spreadProps(__spreadValues({}, s), { isLoading: false })),
+        isLoading: false
+      };
+    }
+    return currentSuggestions;
+  }, [suggestions, currentSuggestions]);
   return {
-    visibleMessages: messages,
-    messages: (0, import_runtime_client_gql8.gqlToAGUI)(messages, actions, coAgentStateRenders),
+    messages: resolvedMessages,
     sendMessage: latestSendMessageFunc,
     appendMessage: latestAppendFunc,
     setMessages: latestSetMessagesFunc,
@@ -1746,54 +905,65 @@ function useCopilotChat(options = {}) {
     stopGeneration: latestStopFunc,
     reset: latestResetFunc,
     deleteMessage: latestDeleteFunc,
-    runChatCompletion: latestRunChatCompletionFunc,
-    isLoading,
-    mcpServers,
-    setMcpServers,
-    suggestions,
-    setSuggestions,
-    generateSuggestions: generateSuggestionsFunc,
-    resetSuggestions,
-    isLoadingSuggestions: isLoadingSuggestionsRef.current,
-    interrupt
+    isAvailable: agentAvailable,
+    isLoading: Boolean(agent == null ? void 0 : agent.isRunning),
+    // mcpServers,
+    // setMcpServers,
+    suggestions: renderedSuggestions.suggestions,
+    setSuggestions: (suggestions2) => copilotkit.addSuggestionsConfig({ suggestions: suggestions2 }),
+    generateSuggestions: () => __async(this, null, function* () {
+      return copilotkit.reloadSuggestions(resolvedAgentId);
+    }),
+    resetSuggestions: () => copilotkit.clearSuggestions(resolvedAgentId),
+    isLoadingSuggestions: renderedSuggestions.isLoading,
+    interrupt,
+    agent,
+    threadId
   };
 }
 function useUpdatedRef(value) {
-  const ref = (0, import_react10.useRef)(value);
-  (0, import_react10.useEffect)(() => {
+  const ref = (0, import_react13.useRef)(value);
+  (0, import_react13.useEffect)(() => {
     ref.current = value;
   }, [value]);
   return ref;
 }
-function defaultSystemMessage(contextString, additionalInstructions) {
-  return `
-Please act as an efficient, competent, conscientious, and industrious professional assistant.
-
-Help the user achieve their goals, and you do so in a way that is as efficient as possible, without unnecessary fluff, but also without sacrificing professionalism.
-Always be polite and respectful, and prefer brevity over verbosity.
-
-The user has provided you with the following context:
-\`\`\`
-${contextString}
-\`\`\`
-
-They have also provided you with functions you can call to initiate actions on their behalf, or functions you can call to receive more information.
-
-Please assist them as best you can.
-
-You can ask them for clarifying questions if needed, but don't be annoying about it. If you can reasonably 'fill in the blanks' yourself, do so.
-
-If you would like to call a function, call it without saying anything else.
-In case of a function error:
-- If this error stems from incorrect function parameters or syntax, you may retry with corrected arguments.
-- If the error's source is unclear or seems unrelated to your input, do not attempt further retries.
-` + (additionalInstructions ? `
-
-${additionalInstructions}` : "");
+function useLegacyCoagentRenderer({
+  copilotkit,
+  agent,
+  agentId,
+  threadId
+}) {
+  return (0, import_react13.useMemo)(() => {
+    if (!copilotkit || !agent) {
+      return null;
+    }
+    return ({ message, position }) => {
+      var _a;
+      const effectiveThreadId = (_a = threadId != null ? threadId : agent.threadId) != null ? _a : "default";
+      const existingRunId = copilotkit.getRunIdForMessage(agentId, effectiveThreadId, message.id);
+      const runId = existingRunId || `pending:${message.id}`;
+      const messageIndex = Math.max(
+        agent.messages.findIndex((msg) => msg.id === message.id),
+        0
+      );
+      const bridgeProps = {
+        message,
+        position,
+        runId,
+        messageIndex,
+        messageIndexInRun: 0,
+        numberOfMessagesInRun: 1,
+        agentId,
+        stateSnapshot: message.state
+      };
+      return (0, import_react13.createElement)(CoAgentStateRenderBridge, bridgeProps);
+    };
+  }, [agent, agentId, copilotkit, threadId]);
 }
 
 // src/hooks/use-copilot-chat.ts
-function useCopilotChat2(options = {}) {
+function useCopilotChat(options = {}) {
   const {
     visibleMessages,
     appendMessage,
@@ -1801,10 +971,11 @@ function useCopilotChat2(options = {}) {
     stopGeneration,
     reset,
     isLoading,
+    isAvailable,
     runChatCompletion,
     mcpServers,
     setMcpServers
-  } = useCopilotChat(options);
+  } = useCopilotChatInternal(options);
   return {
     visibleMessages,
     appendMessage,
@@ -1812,6 +983,7 @@ function useCopilotChat2(options = {}) {
     stopGeneration,
     reset,
     isLoading,
+    isAvailable,
     runChatCompletion,
     mcpServers,
     setMcpServers
@@ -1819,8 +991,8 @@ function useCopilotChat2(options = {}) {
 }
 
 // src/hooks/use-copilot-chat-headless_c.ts
-var import_react11 = require("react");
-var import_shared9 = require("@copilotkit/shared");
+var import_react15 = require("react");
+var import_shared4 = require("@copilotkit/shared");
 var createNonFunctionalReturn = () => ({
   visibleMessages: [],
   messages: [],
@@ -1839,6 +1011,7 @@ var createNonFunctionalReturn = () => ({
   reset: () => {
   },
   isLoading: false,
+  isAvailable: false,
   runChatCompletion: () => __async(void 0, null, function* () {
     return [];
   }),
@@ -1858,21 +1031,21 @@ var createNonFunctionalReturn = () => ({
 function useCopilotChatHeadless_c(options = {}) {
   const { copilotApiConfig, setBannerError } = useCopilotContext();
   const hasPublicApiKey = Boolean(copilotApiConfig.publicApiKey);
-  const internalResult = useCopilotChat(options);
-  (0, import_react11.useEffect)(() => {
+  const internalResult = useCopilotChatInternal(options);
+  (0, import_react15.useEffect)(() => {
     if (!hasPublicApiKey) {
       setBannerError(
-        new import_shared9.CopilotKitError({
+        new import_shared4.CopilotKitError({
           message: (
             // add link to documentation here
             "You're using useCopilotChatHeadless_c, a premium-only feature, which offers extensive headless chat capabilities. To continue, you'll need to provide a free public license key."
           ),
-          code: import_shared9.CopilotKitErrorCode.MISSING_PUBLIC_API_KEY_ERROR,
-          severity: import_shared9.Severity.WARNING,
-          visibility: import_shared9.ErrorVisibility.BANNER
+          code: import_shared4.CopilotKitErrorCode.MISSING_PUBLIC_API_KEY_ERROR,
+          severity: import_shared4.Severity.WARNING,
+          visibility: import_shared4.ErrorVisibility.BANNER
         })
       );
-      import_shared9.styledConsole.logCopilotKitPlatformMessage();
+      import_shared4.styledConsole.logCopilotKitPlatformMessage();
     } else {
       setBannerError(null);
     }
@@ -1884,146 +1057,245 @@ function useCopilotChatHeadless_c(options = {}) {
 }
 
 // src/hooks/use-copilot-action.ts
-var import_shared10 = require("@copilotkit/shared");
-var import_react12 = require("react");
-function useCopilotAction(action, dependencies) {
-  const { setAction, removeAction, actions, chatComponentsCache } = useCopilotContext();
-  const idRef = (0, import_react12.useRef)((0, import_shared10.randomId)());
-  const renderAndWaitRef = (0, import_react12.useRef)(null);
-  const activatingMessageIdRef = (0, import_react12.useRef)(null);
-  const { addToast } = useToast();
-  action = __spreadValues({}, action);
-  if (
-    // renderAndWaitForResponse is not available for catch all actions
-    isFrontendAction(action) && // check if renderAndWaitForResponse is set
-    (action.renderAndWait || action.renderAndWaitForResponse)
-  ) {
-    action._isRenderAndWait = true;
-    const renderAndWait = action.renderAndWait || action.renderAndWaitForResponse;
-    action.renderAndWait = void 0;
-    action.renderAndWaitForResponse = void 0;
-    action._setActivatingMessageId = (id) => {
-      activatingMessageIdRef.current = id;
-    };
-    action.handler = useAsyncCallback(() => __async(this, null, function* () {
-      const currentActivatingId = activatingMessageIdRef.current;
-      let resolve;
-      let reject;
-      const promise = new Promise((resolvePromise, rejectPromise) => {
-        resolve = resolvePromise;
-        reject = rejectPromise;
+var import_react22 = require("react");
+
+// src/hooks/use-frontend-tool.ts
+var import_react16 = __toESM(require("react"));
+var import_shared5 = require("@copilotkit/shared");
+var import_shared6 = require("@copilotkit/shared");
+var import_react17 = require("@copilotkitnext/react");
+function useFrontendTool(tool, dependencies) {
+  const { name, description, parameters, render, followUp } = tool;
+  const zodParameters = (0, import_shared5.getZodParameters)(parameters);
+  const normalizedRender = (() => {
+    if (typeof render === "undefined") {
+      return void 0;
+    }
+    if (typeof render === "string") {
+      const staticRender = render;
+      return () => import_react16.default.createElement(
+        import_react16.default.Fragment,
+        null,
+        staticRender
+      );
+    }
+    return (args) => {
+      const renderArgs = __spreadProps(__spreadValues({}, args), {
+        result: typeof args.result === "string" ? (0, import_shared6.parseJson)(args.result, args.result) : args.result
       });
-      renderAndWaitRef.current = {
-        promise,
-        resolve,
-        reject,
-        messageId: currentActivatingId
-      };
-      const result = yield promise;
-      return result;
-    }), []);
-    action.render = (props) => {
-      const currentRenderMessageId = props.messageId;
-      let status = props.status;
-      if (props.status === "executing") {
-        if (!renderAndWaitRef.current || !renderAndWaitRef.current.promise) {
-          status = "inProgress";
-        } else if (renderAndWaitRef.current.messageId !== currentRenderMessageId && activatingMessageIdRef.current !== currentRenderMessageId) {
-          status = "inProgress";
-        }
+      const rendered = render(renderArgs);
+      if (typeof rendered === "string") {
+        return import_react16.default.createElement(import_react16.default.Fragment, null, rendered);
       }
-      const waitProps = {
-        status,
-        args: props.args,
-        result: props.result,
-        // handler and respond should only be provided if this is the truly active instance
-        // and its promise infrastructure is ready.
-        handler: status === "executing" && renderAndWaitRef.current && renderAndWaitRef.current.messageId === currentRenderMessageId ? renderAndWaitRef.current.resolve : void 0,
-        respond: status === "executing" && renderAndWaitRef.current && renderAndWaitRef.current.messageId === currentRenderMessageId ? renderAndWaitRef.current.resolve : void 0
-      };
-      const isNoArgsRenderWait = (_fn) => {
-        var _a;
-        return ((_a = action.parameters) == null ? void 0 : _a.length) === 0;
-      };
-      if (renderAndWait) {
-        if (isNoArgsRenderWait(renderAndWait)) {
-          return renderAndWait(waitProps);
-        } else {
-          return renderAndWait(waitProps);
+      return rendered != null ? rendered : null;
+    };
+  })();
+  const handlerRef = (0, import_react16.useRef)(tool.handler);
+  (0, import_react16.useEffect)(() => {
+    handlerRef.current = tool.handler;
+  }, [tool.handler, ...dependencies != null ? dependencies : []]);
+  const normalizedHandler = tool.handler ? (args) => {
+    var _a;
+    return (_a = handlerRef.current) == null ? void 0 : _a.call(handlerRef, args);
+  } : void 0;
+  (0, import_react17.useFrontendTool)({
+    name,
+    description,
+    parameters: zodParameters,
+    handler: normalizedHandler,
+    followUp,
+    render: normalizedRender
+  });
+}
+
+// src/hooks/use-render-tool-call.ts
+var import_shared7 = require("@copilotkit/shared");
+var import_react18 = require("react");
+var import_react19 = require("@copilotkitnext/react");
+var import_shared8 = require("@copilotkit/shared");
+function useRenderToolCall2(tool, dependencies) {
+  const { copilotkit } = (0, import_react19.useCopilotKit)();
+  const hasAddedRef = (0, import_react18.useRef)(false);
+  (0, import_react18.useEffect)(() => {
+    const { name, parameters, render } = tool;
+    const zodParameters = (0, import_shared7.getZodParameters)(parameters);
+    const renderToolCall = name === "*" ? (0, import_react19.defineToolCallRenderer)({
+      name: "*",
+      render: (args) => {
+        return render(__spreadProps(__spreadValues({}, args), {
+          result: args.result ? (0, import_shared8.parseJson)(args.result, args.result) : args.result
+        }));
+      }
+    }) : (0, import_react19.defineToolCallRenderer)({
+      name,
+      args: zodParameters,
+      render: (args) => {
+        return render(__spreadProps(__spreadValues({}, args), {
+          result: args.result ? (0, import_shared8.parseJson)(args.result, args.result) : args.result
+        }));
+      }
+    });
+    const existingIndex = copilotkit.renderToolCalls.findIndex((r) => r.name === name);
+    if (existingIndex !== -1) {
+      copilotkit.renderToolCalls.splice(existingIndex, 1);
+    }
+    copilotkit.renderToolCalls.push(renderToolCall);
+    hasAddedRef.current = true;
+    return () => {
+      if (hasAddedRef.current) {
+        const index = copilotkit.renderToolCalls.findIndex((r) => r.name === name);
+        if (index !== -1) {
+          copilotkit.renderToolCalls.splice(index, 1);
         }
+        hasAddedRef.current = false;
       }
-      return (0, import_react12.createElement)(import_react12.Fragment);
     };
-  }
-  if (dependencies === void 0) {
-    if (actions[idRef.current]) {
-      if (isFrontendAction(action)) {
-        actions[idRef.current].handler = action.handler;
+  }, [tool, ...dependencies != null ? dependencies : []]);
+}
+
+// src/hooks/use-human-in-the-loop.ts
+var import_shared9 = require("@copilotkit/shared");
+var import_react20 = require("@copilotkitnext/react");
+var import_core = require("@copilotkitnext/core");
+var import_react21 = __toESM(require("react"));
+function useHumanInTheLoop(tool, dependencies) {
+  const _a = tool, { render } = _a, toolRest = __objRest(_a, ["render"]);
+  const { name, description, parameters, followUp } = toolRest;
+  const zodParameters = (0, import_shared9.getZodParameters)(parameters);
+  const renderRef = (0, import_react21.useRef)(null);
+  (0, import_react21.useEffect)(() => {
+    renderRef.current = (args) => {
+      if (typeof render === "string") {
+        return import_react21.default.createElement(import_react21.default.Fragment, null, render);
       }
-      if (typeof action.render === "function") {
-        if (chatComponentsCache.current !== null) {
-          chatComponentsCache.current.actions[action.name] = action.render;
+      if (!render) {
+        return null;
+      }
+      const renderProps = (() => {
+        const mappedArgs = args.args;
+        switch (args.status) {
+          case import_core.ToolCallStatus.InProgress:
+            return {
+              args: mappedArgs,
+              respond: args.respond,
+              status: args.status,
+              handler: void 0
+            };
+          case import_core.ToolCallStatus.Executing:
+            return {
+              args: mappedArgs,
+              respond: args.respond,
+              status: args.status,
+              handler: () => {
+              }
+            };
+          case import_core.ToolCallStatus.Complete:
+            return {
+              args: mappedArgs,
+              respond: args.respond,
+              status: args.status,
+              result: args.result ? (0, import_shared9.parseJson)(args.result, args.result) : args.result,
+              handler: void 0
+            };
+          default:
+            throw new import_shared9.CopilotKitError({
+              code: import_shared9.CopilotKitErrorCode.UNKNOWN,
+              message: `Invalid tool call status: ${args.status}`
+            });
         }
+      })();
+      const rendered = render(renderProps);
+      if (typeof rendered === "string") {
+        return import_react21.default.createElement(import_react21.default.Fragment, null, rendered);
       }
+      return rendered != null ? rendered : null;
+    };
+  }, [render, ...dependencies != null ? dependencies : []]);
+  (0, import_react20.useHumanInTheLoop)({
+    name,
+    description,
+    followUp,
+    parameters: zodParameters,
+    render: (args) => {
+      var _a2, _b;
+      return (_b = (_a2 = renderRef.current) == null ? void 0 : _a2.call(renderRef, args)) != null ? _b : null;
     }
+  });
+}
+
+// src/hooks/use-copilot-action.ts
+function getActionConfig(action) {
+  if (action.name === "*") {
+    return {
+      type: "render",
+      action
+    };
   }
-  (0, import_react12.useEffect)(() => {
-    const hasDuplicate = Object.values(actions).some(
-      (otherAction) => otherAction.name === action.name && otherAction !== actions[idRef.current]
-    );
-    if (hasDuplicate) {
-      addToast({
-        type: "warning",
-        message: `Found an already registered action with name ${action.name}.`,
-        id: `dup-action-${action.name}`
-      });
+  if ("renderAndWaitForResponse" in action || "renderAndWait" in action) {
+    let render = action.render;
+    if (!render && "renderAndWaitForResponse" in action) {
+      render = action.renderAndWaitForResponse;
+    }
+    if (!render && "renderAndWait" in action) {
+      render = action.renderAndWait;
+    }
+    return {
+      type: "hitl",
+      action: __spreadProps(__spreadValues({}, action), { render })
+    };
+  }
+  if ("available" in action) {
+    if (action.available === "enabled" || action.available === "remote") {
+      return {
+        type: "frontend",
+        action
+      };
     }
-  }, [actions]);
-  (0, import_react12.useEffect)(() => {
-    setAction(idRef.current, action);
-    if (chatComponentsCache.current !== null && action.render !== void 0) {
-      chatComponentsCache.current.actions[action.name] = action.render;
+    if (action.available === "frontend" || action.available === "disabled") {
+      return {
+        type: "render",
+        action
+      };
     }
-    return () => {
-      removeAction(idRef.current);
+  }
+  if ("handler" in action) {
+    return {
+      type: "frontend",
+      action
     };
-  }, [
-    setAction,
-    removeAction,
-    isFrontendAction(action) ? action.description : void 0,
-    action.name,
-    isFrontendAction(action) ? action.disabled : void 0,
-    isFrontendAction(action) ? action.available : void 0,
-    // This should be faster than deep equality checking
-    // In addition, all major JS engines guarantee the order of object keys
-    JSON.stringify(isFrontendAction(action) ? action.parameters : []),
-    // include render only if it's a string
-    typeof action.render === "string" ? action.render : void 0,
-    // dependencies set by the developer
-    ...dependencies || []
-  ]);
+  }
+  throw new Error("Invalid action configuration");
 }
-function isFrontendAction(action) {
-  return action.name !== "*";
+function useCopilotAction(action, dependencies) {
+  const [initialActionConfig] = (0, import_react22.useState)(getActionConfig(action));
+  const currentActionConfig = getActionConfig(action);
+  if (initialActionConfig.type !== currentActionConfig.type) {
+    throw new Error("Action configuration changed between renders");
+  }
+  switch (currentActionConfig.type) {
+    case "render":
+      return useRenderToolCall2(currentActionConfig.action, dependencies);
+    case "hitl":
+      return useHumanInTheLoop(currentActionConfig.action, dependencies);
+    case "frontend":
+      return useFrontendTool(currentActionConfig.action, dependencies);
+    default:
+      throw new Error("Invalid action configuration");
+  }
 }
 
 // src/hooks/use-coagent-state-render.ts
-var import_react13 = require("react");
-var import_shared11 = require("@copilotkit/shared");
+var import_react23 = require("react");
+var import_shared10 = require("@copilotkit/shared");
 function useCoAgentStateRender(action, dependencies) {
-  const {
-    setCoAgentStateRender,
-    removeCoAgentStateRender,
-    coAgentStateRenders,
-    chatComponentsCache,
-    availableAgents
-  } = (0, import_react13.useContext)(CopilotContext);
-  const idRef = (0, import_react13.useRef)((0, import_shared11.randomId)());
+  const { chatComponentsCache, availableAgents } = (0, import_react23.useContext)(CopilotContext);
+  const { setCoAgentStateRender, removeCoAgentStateRender, coAgentStateRenders } = useCoAgentStateRenders();
+  const idRef = (0, import_react23.useRef)((0, import_shared10.randomId)());
   const { setBannerError, addToast } = useToast();
-  (0, import_react13.useEffect)(() => {
+  (0, import_react23.useEffect)(() => {
     if ((availableAgents == null ? void 0 : availableAgents.length) && !availableAgents.some((a) => a.name === action.name)) {
       const message = `(useCoAgentStateRender): Agent "${action.name}" not found. Make sure the agent exists and is properly configured.`;
-      const agentError = new import_shared11.CopilotKitAgentDiscoveryError({
+      const agentError = new import_shared10.CopilotKitAgentDiscoveryError({
         agentName: action.name,
         availableAgents: availableAgents.map((a) => ({ name: a.name, id: a.id }))
       });
@@ -2041,7 +1313,7 @@ function useCoAgentStateRender(action, dependencies) {
       }
     }
   }
-  (0, import_react13.useEffect)(() => {
+  (0, import_react23.useEffect)(() => {
     const currentId = idRef.current;
     const hasDuplicate = Object.entries(coAgentStateRenders).some(([id, otherAction]) => {
       if (id === currentId)
@@ -2065,7 +1337,7 @@ function useCoAgentStateRender(action, dependencies) {
       });
     }
   }, [coAgentStateRenders]);
-  (0, import_react13.useEffect)(() => {
+  (0, import_react23.useEffect)(() => {
     setCoAgentStateRender(idRef.current, action);
     if (chatComponentsCache.current !== null && action.render !== void 0) {
       chatComponentsCache.current.coAgentStateRenders[key] = action.render;
@@ -2085,11 +1357,11 @@ function useCoAgentStateRender(action, dependencies) {
 }
 
 // src/hooks/use-make-copilot-document-readable.ts
-var import_react14 = require("react");
+var import_react24 = require("react");
 function useMakeCopilotDocumentReadable(document, categories, dependencies = []) {
   const { addDocumentContext, removeDocumentContext } = useCopilotContext();
-  const idRef = (0, import_react14.useRef)();
-  (0, import_react14.useEffect)(() => {
+  const idRef = (0, import_react24.useRef)(void 0);
+  (0, import_react24.useEffect)(() => {
     const id = addDocumentContext(document, categories);
     idRef.current = id;
     return () => {
@@ -2100,275 +1372,320 @@ function useMakeCopilotDocumentReadable(document, categories, dependencies = [])
 }
 
 // src/hooks/use-copilot-readable.ts
-var import_react15 = require("react");
-function convertToJSON(description, value) {
-  return `${description}: ${typeof value === "string" ? value : JSON.stringify(value)}`;
-}
-function useCopilotReadable({
-  description,
-  value,
-  parentId,
-  categories,
-  convert,
-  available = "enabled"
-}, dependencies) {
-  const { addContext, removeContext } = useCopilotContext();
-  const idRef = (0, import_react15.useRef)();
-  convert = convert || convertToJSON;
-  const information = convert(description, value);
-  (0, import_react15.useEffect)(() => {
-    if (available === "disabled")
+var import_react25 = require("@copilotkitnext/react");
+var import_react26 = require("react");
+function useCopilotReadable({ description, value, convert, available }, dependencies) {
+  const { copilotkit } = (0, import_react25.useCopilotKit)();
+  const ctxIdRef = (0, import_react26.useRef)(void 0);
+  (0, import_react26.useEffect)(() => {
+    if (!copilotkit)
       return;
-    const id = addContext(information, parentId, categories);
-    idRef.current = id;
+    const found = Object.entries(copilotkit.context).find(([id, ctxItem]) => {
+      return JSON.stringify({ description, value }) == JSON.stringify(ctxItem);
+    });
+    if (found) {
+      ctxIdRef.current = found[0];
+      if (available === "disabled")
+        copilotkit.removeContext(ctxIdRef.current);
+      return;
+    }
+    if (!found && available === "disabled")
+      return;
+    ctxIdRef.current = copilotkit.addContext({
+      description,
+      value: (convert != null ? convert : JSON.stringify)(value)
+    });
     return () => {
-      removeContext(id);
+      if (!ctxIdRef.current)
+        return;
+      copilotkit.removeContext(ctxIdRef.current);
     };
-  }, [available, information, parentId, addContext, removeContext, ...dependencies || []]);
-  return idRef.current;
+  }, [description, value, convert]);
+  return ctxIdRef.current;
 }
 
 // src/hooks/use-coagent.ts
-var import_react16 = require("react");
-var import_shared12 = require("@copilotkit/shared");
+var import_react27 = require("react");
+var import_react28 = require("@copilotkitnext/react");
 function useCoAgent(options) {
-  const context = useCopilotContext();
-  const { availableAgents, onError } = context;
-  const { setBannerError } = useToast();
-  const lastLoadedThreadId = (0, import_react16.useRef)();
-  const lastLoadedState = (0, import_react16.useRef)();
-  const { name } = options;
-  (0, import_react16.useEffect)(() => {
-    if ((availableAgents == null ? void 0 : availableAgents.length) && !availableAgents.some((a) => a.name === name)) {
-      const message = `(useCoAgent): Agent "${name}" not found. Make sure the agent exists and is properly configured.`;
-      console.warn(message);
-      const agentError = new import_shared12.CopilotKitAgentDiscoveryError({
-        agentName: name,
-        availableAgents: availableAgents.map((a) => ({ name: a.name, id: a.id }))
-      });
-      setBannerError(agentError);
-    }
-  }, [availableAgents]);
-  const { getMessagesFromTap } = useMessagesTap();
-  const { coagentStates, coagentStatesRef, setCoagentStatesWithRef, threadId, copilotApiConfig } = context;
-  const { sendMessage, runChatCompletion } = useCopilotChat();
-  const headers = __spreadValues({}, copilotApiConfig.headers || {});
-  const runtimeClient = useCopilotRuntimeClient({
-    url: copilotApiConfig.chatApiEndpoint,
-    publicApiKey: copilotApiConfig.publicApiKey,
-    headers,
-    credentials: copilotApiConfig.credentials,
-    showDevConsole: context.showDevConsole,
-    onError
-  });
-  const setState = (0, import_react16.useCallback)(
+  const { agent } = (0, import_react28.useAgent)({ agentId: options.name });
+  const { copilotkit } = (0, import_react28.useCopilotKit)();
+  const nodeName = useAgentNodeName(options.name);
+  const handleStateUpdate = (0, import_react27.useCallback)(
     (newState) => {
-      let coagentState = getCoagentState({ coagentStates, name, options });
-      const updatedState = typeof newState === "function" ? newState(coagentState.state) : newState;
-      setCoagentStatesWithRef(__spreadProps(__spreadValues({}, coagentStatesRef.current), {
-        [name]: __spreadProps(__spreadValues({}, coagentState), {
-          state: updatedState
-        })
-      }));
+      if (!agent)
+        return;
+      if (typeof newState === "function") {
+        const updater = newState;
+        agent.setState(updater(agent.state));
+      } else {
+        agent.setState(__spreadValues(__spreadValues({}, agent.state), newState));
+      }
     },
-    [coagentStates, name]
+    [agent == null ? void 0 : agent.state, agent == null ? void 0 : agent.setState]
   );
-  (0, import_react16.useEffect)(() => {
-    const fetchAgentState = () => __async(this, null, function* () {
-      var _a, _b, _c, _d;
-      if (!threadId || threadId === lastLoadedThreadId.current)
-        return;
-      const result = yield runtimeClient.loadAgentState({
-        threadId,
-        agentName: name
+  (0, import_react27.useEffect)(() => {
+    var _a;
+    if (!options.config && !options.configurable)
+      return;
+    let config = (_a = options.config) != null ? _a : {};
+    if (options.configurable) {
+      config = __spreadProps(__spreadValues({}, config), {
+        configurable: __spreadValues(__spreadValues({}, options.configurable), config.configurable)
       });
-      if (result.error) {
-        return;
-      }
-      const newState = (_b = (_a = result.data) == null ? void 0 : _a.loadAgentState) == null ? void 0 : _b.state;
-      if (newState === lastLoadedState.current)
-        return;
-      if (((_d = (_c = result.data) == null ? void 0 : _c.loadAgentState) == null ? void 0 : _d.threadExists) && newState && newState != "{}") {
-        lastLoadedState.current = newState;
-        lastLoadedThreadId.current = threadId;
-        const fetchedState = (0, import_shared12.parseJson)(newState, {});
-        isExternalStateManagement(options) ? options.setState(fetchedState) : setState(fetchedState);
-      }
-    });
-    void fetchAgentState();
-  }, [threadId]);
-  (0, import_react16.useEffect)(() => {
+    }
+    copilotkit.setProperties(config);
+  }, [options.config, options.configurable]);
+  const externalStateStr = (0, import_react27.useMemo)(
+    () => isExternalStateManagement(options) ? JSON.stringify(options.state) : void 0,
+    [isExternalStateManagement(options) ? JSON.stringify(options.state) : void 0]
+  );
+  (0, import_react27.useEffect)(() => {
+    if ((agent == null ? void 0 : agent.state) && isExternalStateManagement(options) && JSON.stringify(options.state) !== JSON.stringify(agent.state)) {
+      handleStateUpdate(options.state);
+    }
+  }, [agent, externalStateStr, handleStateUpdate]);
+  const hasStateValues = (0, import_react27.useCallback)((value) => {
+    return Boolean(value && Object.keys(value).length);
+  }, []);
+  const initialStateRef = (0, import_react27.useRef)(
+    isExternalStateManagement(options) ? options.state : "initialState" in options ? options.initialState : void 0
+  );
+  (0, import_react27.useEffect)(() => {
     if (isExternalStateManagement(options)) {
-      setState(options.state);
-    } else if (coagentStates[name] === void 0) {
-      setState(options.initialState === void 0 ? {} : options.initialState);
+      initialStateRef.current = options.state;
+    } else if ("initialState" in options) {
+      initialStateRef.current = options.initialState;
     }
   }, [
-    isExternalStateManagement(options) ? JSON.stringify(options.state) : void 0,
-    // reset initialstate on reset
-    coagentStates[name] === void 0
+    isExternalStateManagement(options) ? JSON.stringify(options.state) : "initialState" in options ? JSON.stringify(options.initialState) : void 0
   ]);
-  (0, import_react16.useEffect)(() => {
-    const newConfig = options.config ? options.config : options.configurable ? { configurable: options.configurable } : void 0;
-    if (newConfig === void 0)
+  (0, import_react27.useEffect)(() => {
+    if (!agent)
       return;
-    setCoagentStatesWithRef((prev) => {
-      var _a;
-      const existing = (_a = prev[name]) != null ? _a : {
-        name,
-        state: isInternalStateManagementWithInitial(options) ? options.initialState : {},
-        config: {},
-        running: false,
-        active: false,
-        threadId: void 0,
-        nodeName: void 0,
-        runId: void 0
-      };
-      if (JSON.stringify(existing.config) === JSON.stringify(newConfig)) {
-        return prev;
+    const subscriber = {
+      onStateChanged: (args) => {
+        if (isExternalStateManagement(options)) {
+          options.setState(args.state);
+        }
+      },
+      onRunInitialized: (args) => {
+        const runHasState = hasStateValues(args.state);
+        if (runHasState) {
+          handleStateUpdate(args.state);
+          return;
+        }
+        if (hasStateValues(agent.state)) {
+          return;
+        }
+        if (initialStateRef.current !== void 0) {
+          handleStateUpdate(initialStateRef.current);
+        }
       }
-      return __spreadProps(__spreadValues({}, prev), {
-        [name]: __spreadProps(__spreadValues({}, existing), {
-          config: newConfig
-        })
-      });
-    });
-  }, [JSON.stringify(options.config), JSON.stringify(options.configurable)]);
-  const runAgentCallback = useAsyncCallback(
-    (hint) => __async(this, null, function* () {
-      yield runAgent(name, context, getMessagesFromTap(), sendMessage, runChatCompletion, hint);
-    }),
-    [name, context, sendMessage, runChatCompletion]
-  );
-  return (0, import_react16.useMemo)(() => {
-    const coagentState = getCoagentState({ coagentStates, name, options });
-    return {
-      name,
-      nodeName: coagentState.nodeName,
-      threadId: coagentState.threadId,
-      running: coagentState.running,
-      state: coagentState.state,
-      setState: isExternalStateManagement(options) ? options.setState : setState,
-      start: () => startAgent(name, context),
-      stop: () => stopAgent(name, context),
-      run: runAgentCallback
     };
-  }, [name, coagentStates, options, setState, runAgentCallback]);
-}
-function startAgent(name, context) {
-  const { setAgentSession } = context;
-  setAgentSession({
-    agentName: name
-  });
-}
-function stopAgent(name, context) {
-  const { agentSession, setAgentSession } = context;
-  if (agentSession && agentSession.agentName === name) {
-    setAgentSession(null);
-    context.setCoagentStates((prevAgentStates) => {
-      return __spreadProps(__spreadValues({}, prevAgentStates), {
-        [name]: __spreadProps(__spreadValues({}, prevAgentStates[name]), {
-          running: false,
-          active: false,
-          threadId: void 0,
-          nodeName: void 0,
-          runId: void 0
-        })
-      });
-    });
-  } else {
-    console.warn(`No agent session found for ${name}`);
-  }
-}
-function runAgent(name, context, messages, sendMessage, runChatCompletion, hint) {
-  return __async(this, null, function* () {
-    var _a, _b;
-    const { agentSession, setAgentSession } = context;
-    if (!agentSession || agentSession.agentName !== name) {
-      setAgentSession({
-        agentName: name
+    const subscription = agent.subscribe(subscriber);
+    return () => {
+      subscription.unsubscribe();
+    };
+  }, [agent, handleStateUpdate, hasStateValues]);
+  return (0, import_react27.useMemo)(() => {
+    var _a, _b, _c;
+    if (!agent) {
+      const noop = () => {
+      };
+      const noopAsync = () => __async(this, null, function* () {
       });
+      const initialState = (
+        // prefer externally provided state if available
+        (_b = (_a = "state" in options && options.state) != null ? _a : (
+          // then initialState if provided
+          "initialState" in options && options.initialState
+        )) != null ? _b : {}
+      );
+      return {
+        name: options.name,
+        nodeName,
+        threadId: void 0,
+        running: false,
+        state: initialState,
+        setState: noop,
+        start: noop,
+        stop: noop,
+        run: noopAsync
+      };
     }
-    let previousState = null;
-    for (let i = messages.length - 1; i >= 0; i--) {
-      const message = messages[i];
-      if (message.isAgentStateMessage() && message.agentName === name) {
-        previousState = message.state;
-      }
-    }
-    let state = ((_b = (_a = context.coagentStatesRef.current) == null ? void 0 : _a[name]) == null ? void 0 : _b.state) || {};
-    if (hint) {
-      const hintMessage = hint({ previousState, currentState: state });
-      if (hintMessage) {
-        yield sendMessage(hintMessage);
-      } else {
-        yield runChatCompletion();
-      }
-    } else {
-      yield runChatCompletion();
-    }
-  });
+    return {
+      name: (_c = agent == null ? void 0 : agent.agentId) != null ? _c : options.name,
+      nodeName,
+      threadId: agent.threadId,
+      running: agent.isRunning,
+      state: agent.state,
+      setState: handleStateUpdate,
+      // TODO: start and run both have same thing. need to figure out
+      start: agent.runAgent,
+      stop: agent.abortRun,
+      run: agent.runAgent
+    };
+  }, [
+    agent == null ? void 0 : agent.state,
+    agent == null ? void 0 : agent.runAgent,
+    agent == null ? void 0 : agent.abortRun,
+    agent == null ? void 0 : agent.runAgent,
+    agent == null ? void 0 : agent.threadId,
+    agent == null ? void 0 : agent.isRunning,
+    agent == null ? void 0 : agent.agentId,
+    handleStateUpdate,
+    options.name
+  ]);
 }
 var isExternalStateManagement = (options) => {
   return "state" in options && "setState" in options;
 };
-var isInternalStateManagementWithInitial = (options) => {
-  return "initialState" in options;
+
+// src/hooks/use-copilot-runtime-client.ts
+var import_runtime_client_gql3 = require("@copilotkit/runtime-client-gql");
+var import_react29 = require("react");
+var import_shared11 = require("@copilotkit/shared");
+var useCopilotRuntimeClient = (options) => {
+  const { setBannerError } = useToast();
+  const _a = options, { showDevConsole, onError } = _a, runtimeOptions = __objRest(_a, ["showDevConsole", "onError"]);
+  const lastStructuredErrorRef = (0, import_react29.useRef)(null);
+  const traceUIError = (error, originalError) => __async(void 0, null, function* () {
+    try {
+      const errorEvent = {
+        type: "error",
+        timestamp: Date.now(),
+        context: {
+          source: "ui",
+          request: {
+            operation: "runtimeClient",
+            url: runtimeOptions.url,
+            startTime: Date.now()
+          },
+          technical: {
+            environment: "browser",
+            userAgent: typeof navigator !== "undefined" ? navigator.userAgent : void 0,
+            stackTrace: originalError instanceof Error ? originalError.stack : void 0
+          }
+        },
+        error
+      };
+      yield onError(errorEvent);
+    } catch (error2) {
+      console.error("Error in onError handler:", error2);
+    }
+  });
+  const runtimeClient = (0, import_react29.useMemo)(() => {
+    return new import_runtime_client_gql3.CopilotRuntimeClient(__spreadProps(__spreadValues({}, runtimeOptions), {
+      handleGQLErrors: (error) => {
+        var _a2;
+        if ((_a2 = error.graphQLErrors) == null ? void 0 : _a2.length) {
+          const graphQLErrors = error.graphQLErrors;
+          const routeError = (gqlError) => {
+            const extensions = gqlError.extensions;
+            const visibility = extensions == null ? void 0 : extensions.visibility;
+            if (visibility === import_shared11.ErrorVisibility.SILENT) {
+              console.error("CopilotKit Silent Error:", gqlError.message);
+              return;
+            }
+            const now = Date.now();
+            const errorMessage = gqlError.message;
+            if (lastStructuredErrorRef.current && lastStructuredErrorRef.current.message === errorMessage && now - lastStructuredErrorRef.current.timestamp < 150) {
+              return;
+            }
+            lastStructuredErrorRef.current = { message: errorMessage, timestamp: now };
+            const ckError = createStructuredError(gqlError);
+            if (ckError) {
+              setBannerError(ckError);
+              traceUIError(ckError, gqlError);
+            } else {
+              const fallbackError = new import_shared11.CopilotKitError({
+                message: gqlError.message,
+                code: import_shared11.CopilotKitErrorCode.UNKNOWN
+              });
+              setBannerError(fallbackError);
+              traceUIError(fallbackError, gqlError);
+            }
+          };
+          graphQLErrors.forEach(routeError);
+        } else {
+          const fallbackError = new import_shared11.CopilotKitError({
+            message: (error == null ? void 0 : error.message) || String(error),
+            code: import_shared11.CopilotKitErrorCode.UNKNOWN
+          });
+          setBannerError(fallbackError);
+          traceUIError(fallbackError, error);
+        }
+      },
+      handleGQLWarning: (message) => {
+        console.warn(message);
+        const warningError = new import_shared11.CopilotKitError({
+          message,
+          code: import_shared11.CopilotKitErrorCode.UNKNOWN
+        });
+        setBannerError(warningError);
+      }
+    }));
+  }, [runtimeOptions, setBannerError, onError]);
+  return runtimeClient;
 };
-var getCoagentState = ({
-  coagentStates,
-  name,
-  options
-}) => {
-  if (coagentStates[name]) {
-    return coagentStates[name];
-  } else {
-    return {
-      name,
-      state: isInternalStateManagementWithInitial(options) ? options.initialState : {},
-      config: options.config ? options.config : options.configurable ? { configurable: options.configurable } : {},
-      running: false,
-      active: false,
-      threadId: void 0,
-      nodeName: void 0,
-      runId: void 0
-    };
+function createStructuredError(gqlError) {
+  var _a, _b, _c;
+  const extensions = gqlError.extensions;
+  const originalError = extensions == null ? void 0 : extensions.originalError;
+  const message = (originalError == null ? void 0 : originalError.message) || gqlError.message;
+  const code = extensions == null ? void 0 : extensions.code;
+  if (code) {
+    return new import_shared11.CopilotKitError({ message, code });
   }
-};
+  if ((_a = originalError == null ? void 0 : originalError.stack) == null ? void 0 : _a.includes("CopilotApiDiscoveryError")) {
+    return new import_shared11.CopilotKitApiDiscoveryError({ message });
+  }
+  if ((_b = originalError == null ? void 0 : originalError.stack) == null ? void 0 : _b.includes("CopilotKitRemoteEndpointDiscoveryError")) {
+    return new import_shared11.CopilotKitRemoteEndpointDiscoveryError({ message });
+  }
+  if ((_c = originalError == null ? void 0 : originalError.stack) == null ? void 0 : _c.includes("CopilotKitAgentDiscoveryError")) {
+    return new import_shared11.CopilotKitAgentDiscoveryError({
+      agentName: "",
+      availableAgents: []
+    });
+  }
+  return null;
+}
 
 // src/hooks/use-copilot-authenticated-action.ts
-var import_react17 = require("react");
-var import_react18 = __toESM(require("react"));
+var import_react30 = require("react");
+var import_react31 = __toESM(require("react"));
 function useCopilotAuthenticatedAction_c(action, dependencies) {
   const { authConfig_c, authStates_c, setAuthStates_c } = useCopilotContext();
-  const pendingActionRef = (0, import_react17.useRef)(null);
-  const executeAction2 = (0, import_react17.useCallback)(
+  const pendingActionRef = (0, import_react30.useRef)(null);
+  const executeAction = (0, import_react30.useCallback)(
     (props) => {
       if (typeof action.render === "function") {
         return action.render(props);
       }
-      return action.render || import_react18.default.createElement(import_react17.Fragment);
+      return action.render || import_react31.default.createElement(import_react30.Fragment);
     },
     [action]
   );
-  const wrappedRender = (0, import_react17.useCallback)(
+  const wrappedRender = (0, import_react30.useCallback)(
     (props) => {
       const isAuthenticated = Object.values(authStates_c || {}).some(
         (state) => state.status === "authenticated"
       );
       if (!isAuthenticated) {
         pendingActionRef.current = props;
-        return (authConfig_c == null ? void 0 : authConfig_c.SignInComponent) ? import_react18.default.createElement(authConfig_c.SignInComponent, {
+        return (authConfig_c == null ? void 0 : authConfig_c.SignInComponent) ? import_react31.default.createElement(authConfig_c.SignInComponent, {
           onSignInComplete: (authState) => {
             setAuthStates_c == null ? void 0 : setAuthStates_c((prev) => __spreadProps(__spreadValues({}, prev), { [action.name]: authState }));
             if (pendingActionRef.current) {
-              executeAction2(pendingActionRef.current);
+              executeAction(pendingActionRef.current);
               pendingActionRef.current = null;
             }
           }
-        }) : import_react18.default.createElement(import_react17.Fragment);
+        }) : import_react31.default.createElement(import_react30.Fragment);
       }
-      return executeAction2(props);
+      return executeAction(props);
     },
     [action, authStates_c, setAuthStates_c]
   );
@@ -2381,63 +1698,27 @@ function useCopilotAuthenticatedAction_c(action, dependencies) {
 }
 
 // src/hooks/use-langgraph-interrupt.ts
-var import_react19 = require("react");
-var import_shared13 = require("@copilotkit/shared");
+var import_react32 = require("react");
+var import_shared12 = require("@copilotkit/shared");
 function useLangGraphInterrupt(action, dependencies) {
-  var _a;
-  const {
-    setLangGraphInterruptAction,
-    removeLangGraphInterruptAction,
-    langGraphInterruptAction,
-    threadId
-  } = (0, import_react19.useContext)(CopilotContext);
-  const { runChatCompletion } = useCopilotChat();
+  const { setInterruptAction, removeInterruptAction, interruptActions, threadId } = (0, import_react32.useContext)(CopilotContext);
   const { addToast } = useToast();
-  const actionId = (0, import_shared13.dataToUUID)(JSON.stringify(action), "lgAction");
-  const hasAction = (0, import_react19.useMemo)(
-    () => Boolean(langGraphInterruptAction == null ? void 0 : langGraphInterruptAction.id),
-    [langGraphInterruptAction]
-  );
-  const isCurrentAction = (0, import_react19.useMemo)(
-    () => (langGraphInterruptAction == null ? void 0 : langGraphInterruptAction.id) && (langGraphInterruptAction == null ? void 0 : langGraphInterruptAction.id) === actionId,
-    [langGraphInterruptAction]
-  );
-  (0, import_react19.useEffect)(() => {
-    var _a2;
-    if (hasAction && isCurrentAction && ((_a2 = langGraphInterruptAction == null ? void 0 : langGraphInterruptAction.event) == null ? void 0 : _a2.response)) {
-      runChatCompletion();
-    }
-  }, [(_a = langGraphInterruptAction == null ? void 0 : langGraphInterruptAction.event) == null ? void 0 : _a.response, runChatCompletion, hasAction, isCurrentAction]);
-  (0, import_react19.useEffect)(() => {
+  const actionId = (0, import_shared12.dataToUUID)(action, "lgAction");
+  (0, import_react32.useEffect)(() => {
     if (!action)
       return;
-    if (hasAction && !isCurrentAction && !action.enabled) {
-      addToast({
-        type: "warning",
-        message: "An action is already registered for the interrupt event"
-      });
-      return;
-    }
-    if (hasAction && isCurrentAction) {
-      return;
-    }
-    setLangGraphInterruptAction(threadId, __spreadProps(__spreadValues({}, action), { id: actionId }));
-  }, [
-    action,
-    hasAction,
-    isCurrentAction,
-    setLangGraphInterruptAction,
-    removeLangGraphInterruptAction,
-    threadId,
-    ...dependencies || []
-  ]);
+    setInterruptAction(__spreadProps(__spreadValues({}, action), { id: actionId }));
+    return () => {
+      removeInterruptAction(actionId);
+    };
+  }, [setInterruptAction, removeInterruptAction, threadId, actionId, ...dependencies || []]);
 }
 
 // src/hooks/use-copilot-additional-instructions.ts
-var import_react20 = require("react");
+var import_react33 = require("react");
 function useCopilotAdditionalInstructions({ instructions, available = "enabled" }, dependencies) {
   const { setAdditionalInstructions } = useCopilotContext();
-  (0, import_react20.useEffect)(() => {
+  (0, import_react33.useEffect)(() => {
     if (available === "disabled")
       return;
     setAdditionalInstructions((prevInstructions) => [...prevInstructions || [], instructions]);
@@ -2449,42 +1730,27 @@ function useCopilotAdditionalInstructions({ instructions, available = "enabled"
   }, [available, instructions, setAdditionalInstructions, ...dependencies || []]);
 }
 
-// src/hooks/use-frontend-tool.ts
-function useFrontendTool(tool, dependencies) {
-  useCopilotAction(tool, dependencies);
-}
-
-// src/hooks/use-human-in-the-loop.ts
-function useHumanInTheLoop(tool, dependencies) {
-  const _a = tool, { render } = _a, toolRest = __objRest(_a, ["render"]);
-  useCopilotAction(
-    __spreadProps(__spreadValues({}, toolRest), {
-      available: tool.available === "disabled" ? tool.available : "remote",
-      renderAndWaitForResponse: render
-    }),
-    dependencies
-  );
-}
-
-// src/hooks/use-render-tool-call.ts
-function useRenderToolCall(tool, dependencies) {
-  useCopilotAction(
-    __spreadProps(__spreadValues({}, tool), {
-      available: tool.available === "disabled" ? tool.available : "frontend"
-    }),
-    dependencies
-  );
-}
-
 // src/hooks/use-default-tool.ts
 function useDefaultTool(tool, dependencies) {
   useCopilotAction(__spreadProps(__spreadValues({}, tool), { name: "*" }), dependencies);
 }
+
+// src/hooks/use-copilot-chat-suggestions.tsx
+var import_react34 = require("@copilotkitnext/react");
+function useCopilotChatSuggestions(config, dependencies = []) {
+  var _a, _b;
+  const existingConfig = (0, import_react34.useCopilotChatConfiguration)();
+  const resolvedAgentId = (_a = existingConfig == null ? void 0 : existingConfig.agentId) != null ? _a : "default";
+  const available = (_b = config.available === "enabled" ? "always" : config.available) != null ? _b : "before-first-message";
+  const finalSuggestionConfig = __spreadProps(__spreadValues({}, config), {
+    available,
+    consumerAgentId: resolvedAgentId
+    // Use chatConfig.agentId here
+  });
+  (0, import_react34.useConfigureSuggestions)(finalSuggestionConfig, dependencies);
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  runAgent,
-  startAgent,
-  stopAgent,
   useCoAgent,
   useCoAgentStateRender,
   useCopilotAction,
@@ -2493,6 +1759,7 @@ function useDefaultTool(tool, dependencies) {
   useCopilotChat,
   useCopilotChatHeadless_c,
   useCopilotChatInternal,
+  useCopilotChatSuggestions,
   useCopilotReadable,
   useCopilotRuntimeClient,
   useDefaultTool,
@@ -2500,6 +1767,7 @@ function useDefaultTool(tool, dependencies) {
   useHumanInTheLoop,
   useLangGraphInterrupt,
   useLangGraphInterruptRender,
+  useLazyToolRenderer,
   useMakeCopilotDocumentReadable,
   useRenderToolCall
 });