@copilotkit/react-core 1.10.7-next.0 → 1.50.0-beta.1

package/dist/hooks/use-copilot-chat.js

@@ -79,12 +79,12 @@ var __async = (__this, __arguments, generator) => {
 // src/hooks/use-copilot-chat.ts
 var use_copilot_chat_exports = {};
 __export(use_copilot_chat_exports, {
-  useCopilotChat: () => useCopilotChat2
+  useCopilotChat: () => useCopilotChat
 });
 module.exports = __toCommonJS(use_copilot_chat_exports);
 
 // src/hooks/use-copilot-chat_internal.ts
-var import_react9 = require("react");
+var import_react12 = require("react");
 
 // src/context/copilot-context.tsx
 var import_react = __toESM(require("react"));
@@ -94,10 +94,8 @@ var emptyCopilotContext = {
   },
   removeAction: () => {
   },
-  coAgentStateRenders: {},
-  setCoAgentStateRender: () => {
-  },
-  removeCoAgentStateRender: () => {
+  setRegisteredActions: () => "",
+  removeRegisteredAction: () => {
   },
   chatComponentsCache: { current: { actions: {}, coAgentStateRenders: {} } },
   getContextString: (documents, categories) => returnAndThrowInDebug(""),
@@ -117,7 +115,6 @@ var emptyCopilotContext = {
   addDocumentContext: () => returnAndThrowInDebug(""),
   removeDocumentContext: () => {
   },
-  runtimeClient: {},
   copilotApiConfig: new class {
     get chatApiEndpoint() {
       throw new Error("Remember to wrap your app in a `<CopilotKit> {...} </CopilotKit>` !!!");
@@ -157,10 +154,15 @@ var emptyCopilotContext = {
   extensions: {},
   setExtensions: () => {
   },
-  langGraphInterruptAction: null,
-  setLangGraphInterruptAction: () => {
+  interruptActions: {},
+  setInterruptAction: () => {
+  },
+  removeInterruptAction: () => {
+  },
+  interruptEventQueue: {},
+  addInterruptEvent: () => {
   },
-  removeLangGraphInterruptAction: () => {
+  removeInterruptEvent: () => {
   },
   onError: () => {
   },
@@ -185,186 +187,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 = ({
@@ -446,9 +284,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 || "";
@@ -458,7 +296,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]
@@ -466,7 +304,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) {
@@ -477,1173 +315,880 @@ 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_react5 = __toESM(require("react"));
+var import_runtime_client_gql = require("@copilotkit/runtime-client-gql");
+var import_shared2 = require("@copilotkit/shared");
+var InterruptRenderer = ({ event, result, render, resolve }) => {
+  return render({ event, result, resolve });
+};
+function useLangGraphInterruptRender(agent) {
   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,
+    removeInterruptEvent
+  } = useCopilotContext();
+  (0, import_react5.useEffect)(() => {
+    if (!agent)
+      return;
+    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)(JSON.stringify(eventData), "interruptEvents");
+          addInterruptEvent({
+            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]);
-          }
-        }
-        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);
-        }
-        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;
+            event: eventData
           });
-          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__"
-            });
-          }
-          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]
-  );
-  (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;
+    };
+    const { unsubscribe } = agent.subscribe(subscriber);
+    return () => {
+      unsubscribe();
+    };
+  }, [agent, threadId]);
+  const handleResolve = (0, import_react5.useCallback)(
+    (eventId, response) => {
+      agent == null ? void 0 : agent.runAgent({
+        forwardedProps: {
+          command: {
+            resume: response
+          }
         }
-      }, []);
+      });
+      removeInterruptEvent(threadId, eventId);
     },
-    [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]
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [agent, threadId]
   );
-  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_react5.useMemo)(() => {
+    const eventQueue = interruptEventQueue[threadId] || [];
+    const currentQueuedEvent = eventQueue.find((qe) => !qe.event.response);
+    if (!currentQueuedEvent)
+      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: agentSession
+      });
     });
-    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_react5.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_react13 = require("@copilotkitnext/react");
+
+// src/hooks/use-lazy-tool-renderer.tsx
+var import_react6 = require("@copilotkitnext/react");
+var import_react7 = require("react");
+function useLazyToolRenderer() {
+  const renderToolCall = (0, import_react6.useRenderToolCall)();
+  return (0, import_react7.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_react7 = require("react");
-var import_react_dom2 = require("react-dom");
-var import_shared7 = require("@copilotkit/shared");
+// src/hooks/use-configure-chat-suggestions.tsx
+var import_react8 = require("@copilotkitnext/react");
+var import_react9 = require("react");
+function useConfigureChatSuggestions(config, dependencies = []) {
+  const { agentSession } = useCopilotContext();
+  const { copilotkit } = (0, import_react8.useCopilotKit)();
+  const available = config.available === "enabled" ? "always" : config.available;
+  const finalSuggestionConfig = __spreadProps(__spreadValues({}, config), {
+    available,
+    consumerAgentId: agentSession == null ? void 0 : agentSession.agentName
+    // Use chatConfig.agentId here
+  });
+  (0, import_react8.useConfigureSuggestions)(finalSuggestionConfig, { deps: dependencies });
+  const result = (0, import_react8.useSuggestions)({ agentId: agentSession == null ? void 0 : agentSession.agentName });
+  (0, import_react9.useEffect)(() => {
+    if (finalSuggestionConfig.available === "disabled")
+      return;
+    const subscription = copilotkit.subscribe({
+      onAgentsChanged: () => {
+        const agent = copilotkit.getAgent(agentSession == null ? void 0 : agentSession.agentName);
+        if (agent && !agent.isRunning && !result.suggestions.length) {
+          copilotkit.reloadSuggestions(agentSession == null ? void 0 : agentSession.agentName);
+        }
+      }
+    });
+    return () => {
+      subscription.unsubscribe();
+    };
+  }, []);
+  return result;
+}
 
-// src/utils/extract.ts
-var import_shared5 = require("@copilotkit/shared");
-var import_runtime_client_gql4 = require("@copilotkit/runtime-client-gql");
-var import_runtime_client_gql5 = require("@copilotkit/runtime-client-gql");
-function extract(_0) {
-  return __async(this, arguments, function* ({
-    context,
-    instructions,
-    parameters,
-    include,
-    data,
-    abortSignal,
-    stream,
-    requestType = import_runtime_client_gql4.CopilotRequestType.Task,
-    forwardedParameters
-  }) {
-    var _a, _b;
-    const { messages } = context;
-    const action = {
-      name: "extract",
-      description: instructions,
-      parameters,
-      handler: (args) => {
+// ../../node_modules/.pnpm/@ag-ui+core@0.0.42-alpha.1/node_modules/@ag-ui/core/dist/index.mjs
+var import_zod = require("zod");
+var import_zod2 = require("zod");
+var FunctionCallSchema = import_zod.z.object({
+  name: import_zod.z.string(),
+  arguments: import_zod.z.string()
+});
+var ToolCallSchema = import_zod.z.object({
+  id: import_zod.z.string(),
+  type: import_zod.z.literal("function"),
+  function: FunctionCallSchema
+});
+var BaseMessageSchema = import_zod.z.object({
+  id: import_zod.z.string(),
+  role: import_zod.z.string(),
+  content: import_zod.z.string().optional(),
+  name: import_zod.z.string().optional()
+});
+var TextInputContentSchema = import_zod.z.object({
+  type: import_zod.z.literal("text"),
+  text: import_zod.z.string()
+});
+var BinaryInputContentObjectSchema = import_zod.z.object({
+  type: import_zod.z.literal("binary"),
+  mimeType: import_zod.z.string(),
+  id: import_zod.z.string().optional(),
+  url: import_zod.z.string().optional(),
+  data: import_zod.z.string().optional(),
+  filename: import_zod.z.string().optional()
+});
+var ensureBinaryPayload = (value, ctx) => {
+  if (!value.id && !value.url && !value.data) {
+    ctx.addIssue({
+      code: import_zod.z.ZodIssueCode.custom,
+      message: "BinaryInputContent requires at least one of id, url, or data.",
+      path: ["id"]
+    });
+  }
+};
+var BinaryInputContentSchema = BinaryInputContentObjectSchema.superRefine((value, ctx) => {
+  ensureBinaryPayload(value, ctx);
+});
+var InputContentBaseSchema = import_zod.z.discriminatedUnion("type", [
+  TextInputContentSchema,
+  BinaryInputContentObjectSchema
+]);
+var InputContentSchema = InputContentBaseSchema.superRefine((value, ctx) => {
+  if (value.type === "binary") {
+    ensureBinaryPayload(value, ctx);
+  }
+});
+var DeveloperMessageSchema = BaseMessageSchema.extend({
+  role: import_zod.z.literal("developer"),
+  content: import_zod.z.string()
+});
+var SystemMessageSchema = BaseMessageSchema.extend({
+  role: import_zod.z.literal("system"),
+  content: import_zod.z.string()
+});
+var AssistantMessageSchema = BaseMessageSchema.extend({
+  role: import_zod.z.literal("assistant"),
+  content: import_zod.z.string().optional(),
+  toolCalls: import_zod.z.array(ToolCallSchema).optional()
+});
+var UserMessageSchema = BaseMessageSchema.extend({
+  role: import_zod.z.literal("user"),
+  content: import_zod.z.union([import_zod.z.string(), import_zod.z.array(InputContentSchema)])
+});
+var ToolMessageSchema = import_zod.z.object({
+  id: import_zod.z.string(),
+  content: import_zod.z.string(),
+  role: import_zod.z.literal("tool"),
+  toolCallId: import_zod.z.string(),
+  error: import_zod.z.string().optional()
+});
+var ActivityMessageSchema = import_zod.z.object({
+  id: import_zod.z.string(),
+  role: import_zod.z.literal("activity"),
+  activityType: import_zod.z.string(),
+  content: import_zod.z.record(import_zod.z.any())
+});
+var MessageSchema = import_zod.z.discriminatedUnion("role", [
+  DeveloperMessageSchema,
+  SystemMessageSchema,
+  AssistantMessageSchema,
+  UserMessageSchema,
+  ToolMessageSchema,
+  ActivityMessageSchema
+]);
+var RoleSchema = import_zod.z.union([
+  import_zod.z.literal("developer"),
+  import_zod.z.literal("system"),
+  import_zod.z.literal("assistant"),
+  import_zod.z.literal("user"),
+  import_zod.z.literal("tool"),
+  import_zod.z.literal("activity")
+]);
+var ContextSchema = import_zod.z.object({
+  description: import_zod.z.string(),
+  value: import_zod.z.string()
+});
+var ToolSchema = import_zod.z.object({
+  name: import_zod.z.string(),
+  description: import_zod.z.string(),
+  parameters: import_zod.z.any()
+  // JSON Schema for the tool parameters
+});
+var RunAgentInputSchema = import_zod.z.object({
+  threadId: import_zod.z.string(),
+  runId: import_zod.z.string(),
+  parentRunId: import_zod.z.string().optional(),
+  state: import_zod.z.any(),
+  messages: import_zod.z.array(MessageSchema),
+  tools: import_zod.z.array(ToolSchema),
+  context: import_zod.z.array(ContextSchema),
+  forwardedProps: import_zod.z.any()
+});
+var StateSchema = import_zod.z.any();
+var AGUIError = class extends Error {
+  constructor(message) {
+    super(message);
+  }
+};
+var AGUIConnectNotImplementedError = class extends AGUIError {
+  constructor() {
+    super("Connect not implemented. This method is not supported by the current agent.");
+  }
+};
+var TextMessageRoleSchema = import_zod2.z.union([
+  import_zod2.z.literal("developer"),
+  import_zod2.z.literal("system"),
+  import_zod2.z.literal("assistant"),
+  import_zod2.z.literal("user")
+]);
+var EventType = /* @__PURE__ */ ((EventType2) => {
+  EventType2["TEXT_MESSAGE_START"] = "TEXT_MESSAGE_START";
+  EventType2["TEXT_MESSAGE_CONTENT"] = "TEXT_MESSAGE_CONTENT";
+  EventType2["TEXT_MESSAGE_END"] = "TEXT_MESSAGE_END";
+  EventType2["TEXT_MESSAGE_CHUNK"] = "TEXT_MESSAGE_CHUNK";
+  EventType2["THINKING_TEXT_MESSAGE_START"] = "THINKING_TEXT_MESSAGE_START";
+  EventType2["THINKING_TEXT_MESSAGE_CONTENT"] = "THINKING_TEXT_MESSAGE_CONTENT";
+  EventType2["THINKING_TEXT_MESSAGE_END"] = "THINKING_TEXT_MESSAGE_END";
+  EventType2["TOOL_CALL_START"] = "TOOL_CALL_START";
+  EventType2["TOOL_CALL_ARGS"] = "TOOL_CALL_ARGS";
+  EventType2["TOOL_CALL_END"] = "TOOL_CALL_END";
+  EventType2["TOOL_CALL_CHUNK"] = "TOOL_CALL_CHUNK";
+  EventType2["TOOL_CALL_RESULT"] = "TOOL_CALL_RESULT";
+  EventType2["THINKING_START"] = "THINKING_START";
+  EventType2["THINKING_END"] = "THINKING_END";
+  EventType2["STATE_SNAPSHOT"] = "STATE_SNAPSHOT";
+  EventType2["STATE_DELTA"] = "STATE_DELTA";
+  EventType2["MESSAGES_SNAPSHOT"] = "MESSAGES_SNAPSHOT";
+  EventType2["ACTIVITY_SNAPSHOT"] = "ACTIVITY_SNAPSHOT";
+  EventType2["ACTIVITY_DELTA"] = "ACTIVITY_DELTA";
+  EventType2["RAW"] = "RAW";
+  EventType2["CUSTOM"] = "CUSTOM";
+  EventType2["RUN_STARTED"] = "RUN_STARTED";
+  EventType2["RUN_FINISHED"] = "RUN_FINISHED";
+  EventType2["RUN_ERROR"] = "RUN_ERROR";
+  EventType2["STEP_STARTED"] = "STEP_STARTED";
+  EventType2["STEP_FINISHED"] = "STEP_FINISHED";
+  return EventType2;
+})(EventType || {});
+var BaseEventSchema = import_zod2.z.object({
+  type: import_zod2.z.nativeEnum(EventType),
+  timestamp: import_zod2.z.number().optional(),
+  rawEvent: import_zod2.z.any().optional()
+});
+var TextMessageStartEventSchema = BaseEventSchema.extend({
+  type: import_zod2.z.literal(
+    "TEXT_MESSAGE_START"
+    /* TEXT_MESSAGE_START */
+  ),
+  messageId: import_zod2.z.string(),
+  role: TextMessageRoleSchema.default("assistant")
+});
+var TextMessageContentEventSchema = BaseEventSchema.extend({
+  type: import_zod2.z.literal(
+    "TEXT_MESSAGE_CONTENT"
+    /* TEXT_MESSAGE_CONTENT */
+  ),
+  messageId: import_zod2.z.string(),
+  delta: import_zod2.z.string().refine((s) => s.length > 0, "Delta must not be an empty string")
+});
+var TextMessageEndEventSchema = BaseEventSchema.extend({
+  type: import_zod2.z.literal(
+    "TEXT_MESSAGE_END"
+    /* TEXT_MESSAGE_END */
+  ),
+  messageId: import_zod2.z.string()
+});
+var TextMessageChunkEventSchema = BaseEventSchema.extend({
+  type: import_zod2.z.literal(
+    "TEXT_MESSAGE_CHUNK"
+    /* TEXT_MESSAGE_CHUNK */
+  ),
+  messageId: import_zod2.z.string().optional(),
+  role: TextMessageRoleSchema.optional(),
+  delta: import_zod2.z.string().optional()
+});
+var ThinkingTextMessageStartEventSchema = BaseEventSchema.extend({
+  type: import_zod2.z.literal(
+    "THINKING_TEXT_MESSAGE_START"
+    /* THINKING_TEXT_MESSAGE_START */
+  )
+});
+var ThinkingTextMessageContentEventSchema = TextMessageContentEventSchema.omit({
+  messageId: true,
+  type: true
+}).extend({
+  type: import_zod2.z.literal(
+    "THINKING_TEXT_MESSAGE_CONTENT"
+    /* THINKING_TEXT_MESSAGE_CONTENT */
+  )
+});
+var ThinkingTextMessageEndEventSchema = BaseEventSchema.extend({
+  type: import_zod2.z.literal(
+    "THINKING_TEXT_MESSAGE_END"
+    /* THINKING_TEXT_MESSAGE_END */
+  )
+});
+var ToolCallStartEventSchema = BaseEventSchema.extend({
+  type: import_zod2.z.literal(
+    "TOOL_CALL_START"
+    /* TOOL_CALL_START */
+  ),
+  toolCallId: import_zod2.z.string(),
+  toolCallName: import_zod2.z.string(),
+  parentMessageId: import_zod2.z.string().optional()
+});
+var ToolCallArgsEventSchema = BaseEventSchema.extend({
+  type: import_zod2.z.literal(
+    "TOOL_CALL_ARGS"
+    /* TOOL_CALL_ARGS */
+  ),
+  toolCallId: import_zod2.z.string(),
+  delta: import_zod2.z.string()
+});
+var ToolCallEndEventSchema = BaseEventSchema.extend({
+  type: import_zod2.z.literal(
+    "TOOL_CALL_END"
+    /* TOOL_CALL_END */
+  ),
+  toolCallId: import_zod2.z.string()
+});
+var ToolCallResultEventSchema = BaseEventSchema.extend({
+  messageId: import_zod2.z.string(),
+  type: import_zod2.z.literal(
+    "TOOL_CALL_RESULT"
+    /* TOOL_CALL_RESULT */
+  ),
+  toolCallId: import_zod2.z.string(),
+  content: import_zod2.z.string(),
+  role: import_zod2.z.literal("tool").optional()
+});
+var ToolCallChunkEventSchema = BaseEventSchema.extend({
+  type: import_zod2.z.literal(
+    "TOOL_CALL_CHUNK"
+    /* TOOL_CALL_CHUNK */
+  ),
+  toolCallId: import_zod2.z.string().optional(),
+  toolCallName: import_zod2.z.string().optional(),
+  parentMessageId: import_zod2.z.string().optional(),
+  delta: import_zod2.z.string().optional()
+});
+var ThinkingStartEventSchema = BaseEventSchema.extend({
+  type: import_zod2.z.literal(
+    "THINKING_START"
+    /* THINKING_START */
+  ),
+  title: import_zod2.z.string().optional()
+});
+var ThinkingEndEventSchema = BaseEventSchema.extend({
+  type: import_zod2.z.literal(
+    "THINKING_END"
+    /* THINKING_END */
+  )
+});
+var StateSnapshotEventSchema = BaseEventSchema.extend({
+  type: import_zod2.z.literal(
+    "STATE_SNAPSHOT"
+    /* STATE_SNAPSHOT */
+  ),
+  snapshot: StateSchema
+});
+var StateDeltaEventSchema = BaseEventSchema.extend({
+  type: import_zod2.z.literal(
+    "STATE_DELTA"
+    /* STATE_DELTA */
+  ),
+  delta: import_zod2.z.array(import_zod2.z.any())
+  // JSON Patch (RFC 6902)
+});
+var MessagesSnapshotEventSchema = BaseEventSchema.extend({
+  type: import_zod2.z.literal(
+    "MESSAGES_SNAPSHOT"
+    /* MESSAGES_SNAPSHOT */
+  ),
+  messages: import_zod2.z.array(MessageSchema)
+});
+var ActivitySnapshotEventSchema = BaseEventSchema.extend({
+  type: import_zod2.z.literal(
+    "ACTIVITY_SNAPSHOT"
+    /* ACTIVITY_SNAPSHOT */
+  ),
+  messageId: import_zod2.z.string(),
+  activityType: import_zod2.z.string(),
+  content: import_zod2.z.record(import_zod2.z.any()),
+  replace: import_zod2.z.boolean().optional().default(true)
+});
+var ActivityDeltaEventSchema = BaseEventSchema.extend({
+  type: import_zod2.z.literal(
+    "ACTIVITY_DELTA"
+    /* ACTIVITY_DELTA */
+  ),
+  messageId: import_zod2.z.string(),
+  activityType: import_zod2.z.string(),
+  patch: import_zod2.z.array(import_zod2.z.any())
+});
+var RawEventSchema = BaseEventSchema.extend({
+  type: import_zod2.z.literal(
+    "RAW"
+    /* RAW */
+  ),
+  event: import_zod2.z.any(),
+  source: import_zod2.z.string().optional()
+});
+var CustomEventSchema = BaseEventSchema.extend({
+  type: import_zod2.z.literal(
+    "CUSTOM"
+    /* CUSTOM */
+  ),
+  name: import_zod2.z.string(),
+  value: import_zod2.z.any()
+});
+var RunStartedEventSchema = BaseEventSchema.extend({
+  type: import_zod2.z.literal(
+    "RUN_STARTED"
+    /* RUN_STARTED */
+  ),
+  threadId: import_zod2.z.string(),
+  runId: import_zod2.z.string(),
+  parentRunId: import_zod2.z.string().optional(),
+  input: RunAgentInputSchema.optional()
+});
+var RunFinishedEventSchema = BaseEventSchema.extend({
+  type: import_zod2.z.literal(
+    "RUN_FINISHED"
+    /* RUN_FINISHED */
+  ),
+  threadId: import_zod2.z.string(),
+  runId: import_zod2.z.string(),
+  result: import_zod2.z.any().optional()
+});
+var RunErrorEventSchema = BaseEventSchema.extend({
+  type: import_zod2.z.literal(
+    "RUN_ERROR"
+    /* RUN_ERROR */
+  ),
+  message: import_zod2.z.string(),
+  code: import_zod2.z.string().optional()
+});
+var StepStartedEventSchema = BaseEventSchema.extend({
+  type: import_zod2.z.literal(
+    "STEP_STARTED"
+    /* STEP_STARTED */
+  ),
+  stepName: import_zod2.z.string()
+});
+var StepFinishedEventSchema = BaseEventSchema.extend({
+  type: import_zod2.z.literal(
+    "STEP_FINISHED"
+    /* STEP_FINISHED */
+  ),
+  stepName: import_zod2.z.string()
+});
+var EventSchemas = import_zod2.z.discriminatedUnion("type", [
+  TextMessageStartEventSchema,
+  TextMessageContentEventSchema,
+  TextMessageEndEventSchema,
+  TextMessageChunkEventSchema,
+  ThinkingStartEventSchema,
+  ThinkingEndEventSchema,
+  ThinkingTextMessageStartEventSchema,
+  ThinkingTextMessageContentEventSchema,
+  ThinkingTextMessageEndEventSchema,
+  ToolCallStartEventSchema,
+  ToolCallArgsEventSchema,
+  ToolCallEndEventSchema,
+  ToolCallChunkEventSchema,
+  ToolCallResultEventSchema,
+  StateSnapshotEventSchema,
+  StateDeltaEventSchema,
+  MessagesSnapshotEventSchema,
+  ActivitySnapshotEventSchema,
+  ActivityDeltaEventSchema,
+  RawEventSchema,
+  CustomEventSchema,
+  RunStartedEventSchema,
+  RunFinishedEventSchema,
+  RunErrorEventSchema,
+  StepStartedEventSchema,
+  StepFinishedEventSchema
+]);
+
+// src/hooks/use-coagent-state-render-bridge.tsx
+var import_react10 = require("@copilotkitnext/react");
+var import_react11 = require("react");
+var import_shared3 = require("@copilotkit/shared");
+function getStateWithoutConstantKeys(state) {
+  const _a = state, { messages, tools, copilotkit } = _a, stateWithoutConstantKeys = __objRest(_a, ["messages", "tools", "copilotkit"]);
+  return stateWithoutConstantKeys;
+}
+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_react10.useAgent)({ agentId });
+  const [nodeName, setNodeName] = (0, import_react11.useState)(void 0);
+  const runId = (_a = props.runId) != null ? _a : message.runId;
+  const effectiveRunId = runId || "pending";
+  (0, import_react11.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]);
+  if (messageIndexInRun !== 0) {
+    return null;
+  }
+  const getStateRender = (0, import_react11.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_gql4.TextMessage({
-      content: makeSystemMessage(contextString, instructions),
-      role: import_runtime_client_gql4.Role.System
-    });
-    const instructionsMessage = new import_runtime_client_gql4.TextMessage({
-      content: makeInstructionsMessage(instructions),
-      role: import_runtime_client_gql4.Role.User
-    });
-    const response = context.runtimeClient.asStream(
-      context.runtimeClient.generateCopilotResponse({
-        data: {
-          frontend: {
-            actions: [
-              {
-                name: action.name,
-                description: action.description || "",
-                jsonSchema: JSON.stringify((0, import_shared5.actionParametersToJsonSchema)(action.parameters || []))
-              }
-            ],
-            url: window.location.href
-          },
-          messages: (0, import_runtime_client_gql5.convertMessagesToGqlInput)(
-            includeMessages ? [systemMessage, instructionsMessage, ...(0, import_runtime_client_gql5.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)(JSON.stringify(getStateWithoutConstantKeys(c.stateSnapshot))) === (0, import_shared3.dataToUUID)(JSON.stringify(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 (renderClaimedByOtherMessage) {
+      if (renderSnapshot && renderClaimedByOtherMessage.stateSnapshot && !areStatesEquals(renderClaimedByOtherMessage.stateSnapshot, renderSnapshot)) {
+        claimsRef.current[messageId] = { stateRenderId, runId: runId2 };
+        return true;
       }
-      if (abortSignal == null ? void 0 : abortSignal.aborted) {
-        throw new Error("Aborted");
-      }
-      actionExecutionMessage = (0, import_runtime_client_gql4.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_react11.useMemo)(() => {
+    var _a2, _b, _c;
+    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
+  ]);
 }
-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_shared6 = require("@copilotkit/shared");
-var import_runtime_client_gql6 = 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;
+// src/hooks/use-copilot-chat_internal.ts
+function useConfigureSuggestions2(suggestions) {
+  let suggestionsConfig;
+  if (Array.isArray(suggestions)) {
+    suggestionsConfig = {
+      suggestions,
+      available: "always"
+    };
+  } else if (suggestions === "auto") {
+    suggestionsConfig = {
+      available: suggestions === "auto" ? "always" : "disabled",
+      instructions: "Suggest what the user could say next. Provide clear, highly relevant suggestions. Do not literally suggest function calls."
+    };
+  } else {
+    suggestionsConfig = { available: "disabled" };
   }
-  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_shared6.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;
-      }
+  useConfigureChatSuggestions(suggestionsConfig);
+}
+function useCopilotChatInternal({
+  suggestions
+} = {}) {
+  var _a, _b, _c, _d;
+  const { copilotkit } = (0, import_react13.useCopilotKit)();
+  const { threadId, agentSession } = useCopilotContext();
+  const existingConfig = (0, import_react13.useCopilotChatConfiguration)();
+  const [agentAvailable, setAgentAvailable] = (0, import_react12.useState)(false);
+  useConfigureSuggestions2(suggestions);
+  const resolvedAgentId = (_b = (_a = agentSession == null ? void 0 : agentSession.agentName) != null ? _a : existingConfig == null ? void 0 : existingConfig.agentId) != null ? _b : "default";
+  const { agent } = (0, import_react13.useAgent)({ agentId: resolvedAgentId });
+  (0, import_react12.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_gql6.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 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]);
+  const interrupt = useLangGraphInterruptRender(agent);
+  const reset = () => {
+    agent == null ? void 0 : agent.setMessages([]);
+    agent == null ? void 0 : agent.setState(null);
+  };
+  const deleteMessage = (0, import_react12.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_runtime4 = require("react/jsx-runtime");
-var defaultCopilotContextCategories = ["global"];
-
-// src/hooks/use-copilot-chat_internal.ts
-var import_runtime_client_gql7 = require("@copilotkit/runtime-client-gql");
-
-// src/hooks/use-langgraph-interrupt-render.ts
-var import_react8 = __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_react8.default.useRef();
-  const resolveInterrupt = (0, import_react8.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_react8.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_react9.useState)([]);
-  const suggestionsAbortControllerRef = (0, import_react9.useRef)(null);
-  const isLoadingSuggestionsRef = (0, import_react9.useRef)(false);
-  const abortSuggestions = (0, import_react9.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_react12.useCallback)(
+    (messageId) => {
+      return latestDelete.current(messageId);
     },
-    [setSuggestions]
+    [latestDelete]
   );
-  const stableContext = (0, import_react9.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_react9.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_react13.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_react9.useCallback)(() => {
-    setSuggestions([]);
-  }, [setSuggestions]);
-  (0, import_react9.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_react9.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;
+      }
+      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]];
       }
-      if (action) {
-        yield (_a2 = action.handler) == null ? void 0 : _a2.call(action, { state, nodeName });
+      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_react9.useCallback)(() => {
-    const systemMessageMaker = makeSystemMessage2 || defaultSystemMessage;
-    const contextString = getContextString([], defaultCopilotContextCategories);
-    return new import_runtime_client_gql7.TextMessage({
-      content: systemMessageMaker(contextString, chatInstructions),
-      role: import_runtime_client_gql7.Role.System
-    });
-  }, [getContextString, makeSystemMessage2, chatInstructions]);
-  const deleteMessage = (0, import_react9.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);
+        }
+      }
+    }),
+    [agent, copilotkit, resolvedAgentId]
   );
-  const { append, reload, stop, runChatCompletion } = useChat(__spreadProps(__spreadValues({}, options), {
-    actions: Object.values(actions),
-    copilotConfig: copilotApiConfig,
-    initialMessages: (0, import_runtime_client_gql7.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_gql7.aguiToGQL)([message])[0], options2);
-    }),
-    [latestAppend]
+  const latestSetMessages = useUpdatedRef(agent == null ? void 0 : agent.setMessages);
+  const latestSetMessagesFunc = (0, import_react12.useCallback)(
+    (messages) => {
+      var _a2, _b2;
+      if (messages.every((message) => message instanceof import_runtime_client_gql2.Message)) {
+        return (_a2 = latestSetMessages.current) == null ? void 0 : _a2.call(latestSetMessages, (0, import_runtime_client_gql2.gqlToAGUI)(messages));
+      }
+      return (_b2 = latestSetMessages.current) == null ? void 0 : _b2.call(latestSetMessages, messages);
+    },
+    [latestSetMessages, agent]
   );
   const latestReload = useUpdatedRef(reload);
   const latestReloadFunc = useAsyncCallback(
@@ -1652,61 +1197,81 @@ function useCopilotChat(options = {}) {
     }),
     [latestReload]
   );
-  const latestStop = useUpdatedRef(stop);
-  const latestStopFunc = (0, import_react9.useCallback)(() => {
-    return latestStop.current();
+  const latestStop = useUpdatedRef(agent == null ? void 0 : agent.abortRun);
+  const latestStopFunc = (0, import_react12.useCallback)(() => {
+    var _a2;
+    return (_a2 = latestStop.current) == null ? void 0 : _a2.call(latestStop);
   }, [latestStop]);
-  const latestDelete = useUpdatedRef(deleteMessage);
-  const latestDeleteFunc = (0, import_react9.useCallback)(
-    (messageId) => {
-      return latestDelete.current(messageId);
-    },
-    [latestDelete]
-  );
-  const latestSetMessages = useUpdatedRef(setMessages);
-  const latestSetMessagesFunc = (0, import_react9.useCallback)(
-    (messages2) => {
-      if (messages2.every((message) => message instanceof import_runtime_client_gql7.Message)) {
-        return latestSetMessages.current(messages2);
+  const latestReset = useUpdatedRef(reset);
+  const latestResetFunc = (0, import_react12.useCallback)(() => {
+    return latestReset.current();
+  }, [latestReset]);
+  const lazyToolRendered = useLazyToolRenderer();
+  const renderCustomMessage = (0, import_react13.useRenderCustomMessages)();
+  const legacyCustomMessageRenderer = useLegacyCoagentRenderer({
+    copilotkit,
+    agent,
+    agentId: resolvedAgentId,
+    threadId: (_c = existingConfig == null ? void 0 : existingConfig.threadId) != null ? _c : threadId
+  });
+  const allMessages = (_d = agent == null ? void 0 : agent.messages) != null ? _d : [];
+  const resolvedMessages = (0, import_react12.useMemo)(() => {
+    let processedMessages = allMessages.map((message) => {
+      if (message.role !== "assistant") {
+        return message;
       }
-      return latestSetMessages.current((0, import_runtime_client_gql7.aguiToGQL)(messages2));
-    },
-    [latestSetMessages]
-  );
-  const latestRunChatCompletion = useUpdatedRef(runChatCompletion);
-  const latestRunChatCompletionFunc = useAsyncCallback(() => __async(this, null, function* () {
-    return yield latestRunChatCompletion.current();
-  }), [latestRunChatCompletion]);
-  const reset = (0, import_react9.useCallback)(() => {
-    latestStopFunc();
-    setMessages([]);
-    setRunId(null);
-    setCoagentStatesWithRef({});
-    let initialAgentSession = null;
-    if (agentLock) {
-      initialAgentSession = {
-        agentName: agentLock
+      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");
+    if (legacyCustomMessageRenderer && !hasAssistantMessages) {
+      const placeholderId = `coagent-state-render-${resolvedAgentId}`;
+      const placeholderMessage = {
+        id: placeholderId,
+        role: "assistant",
+        content: "",
+        name: "coagent-state-render"
       };
+      processedMessages = [
+        ...processedMessages,
+        __spreadProps(__spreadValues({}, placeholderMessage), {
+          generativeUI: () => legacyCustomMessageRenderer({
+            message: placeholderMessage,
+            position: "before"
+          })
+        })
+      ];
     }
-    setAgentSession(initialAgentSession);
-    resetSuggestions();
+    return processedMessages;
   }, [
-    latestStopFunc,
-    setMessages,
-    setThreadId,
-    setCoagentStatesWithRef,
-    setAgentSession,
-    agentLock,
-    resetSuggestions
+    agent == null ? void 0 : agent.messages,
+    lazyToolRendered,
+    allMessages,
+    renderCustomMessage,
+    legacyCustomMessageRenderer,
+    resolvedAgentId
   ]);
-  const latestReset = useUpdatedRef(reset);
-  const latestResetFunc = (0, import_react9.useCallback)(() => {
-    return latestReset.current();
-  }, [latestReset]);
-  const interrupt = useLangGraphInterruptRender();
   return {
-    visibleMessages: messages,
-    messages: (0, import_runtime_client_gql7.gqlToAGUI)(messages, actions, coAgentStateRenders),
+    messages: resolvedMessages,
     sendMessage: latestSendMessageFunc,
     appendMessage: latestAppendFunc,
     setMessages: latestSetMessagesFunc,
@@ -1714,54 +1279,66 @@ 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: currentSuggestions.suggestions,
+    setSuggestions: (suggestions2) => copilotkit.addSuggestionsConfig({ suggestions: suggestions2 }),
+    generateSuggestions: () => __async(this, null, function* () {
+      return copilotkit.reloadSuggestions(resolvedAgentId);
+    }),
+    resetSuggestions: () => copilotkit.clearSuggestions(resolvedAgentId),
+    isLoadingSuggestions: currentSuggestions.isLoading,
+    interrupt,
+    agent,
+    threadId
   };
 }
 function useUpdatedRef(value) {
-  const ref = (0, import_react9.useRef)(value);
-  (0, import_react9.useEffect)(() => {
+  const ref = (0, import_react12.useRef)(value);
+  (0, import_react12.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_react12.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_react12.createElement)(CoAgentStateRenderBridge, bridgeProps);
+    };
+  }, [agent, agentId, copilotkit, threadId]);
 }
 
 // src/hooks/use-copilot-chat.ts
-function useCopilotChat2(options = {}) {
+function useCopilotChat(options = {}) {
   const {
     visibleMessages,
     appendMessage,
@@ -1769,10 +1346,11 @@ function useCopilotChat2(options = {}) {
     stopGeneration,
     reset,
     isLoading,
+    isAvailable,
     runChatCompletion,
     mcpServers,
     setMcpServers
-  } = useCopilotChat(options);
+  } = useCopilotChatInternal(options);
   return {
     visibleMessages,
     appendMessage,
@@ -1780,6 +1358,7 @@ function useCopilotChat2(options = {}) {
     stopGeneration,
     reset,
     isLoading,
+    isAvailable,
     runChatCompletion,
     mcpServers,
     setMcpServers