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

package/dist/chunk-UJBV5GAG.mjs

@@ -0,0 +1,767 @@
+import {
+  useLazyToolRenderer
+} from "./chunk-ZVF5Q6IH.mjs";
+import {
+  useLangGraphInterruptRender
+} from "./chunk-R4MR43UQ.mjs";
+import {
+  useConfigureChatSuggestions
+} from "./chunk-CB7CRBDG.mjs";
+import {
+  useAsyncCallback
+} from "./chunk-6PUNP7CD.mjs";
+import {
+  CoAgentStateRenderBridge
+} from "./chunk-NROJOTQP.mjs";
+import {
+  useCopilotContext
+} from "./chunk-WVLHXIFP.mjs";
+import {
+  __async,
+  __spreadProps,
+  __spreadValues
+} from "./chunk-SKC7AJIV.mjs";
+
+// src/hooks/use-copilot-chat_internal.ts
+import { useRef, useEffect, useCallback, useMemo, useState, createElement } from "react";
+import { gqlToAGUI, Message as DeprecatedGqlMessage } from "@copilotkit/runtime-client-gql";
+import {
+  useAgent,
+  useCopilotChatConfiguration,
+  useCopilotKit,
+  useRenderCustomMessages,
+  useSuggestions
+} from "@copilotkitnext/react";
+
+// ../../node_modules/.pnpm/@ag-ui+core@0.0.42-alpha.1/node_modules/@ag-ui/core/dist/index.mjs
+import { z } from "zod";
+import { z as z2 } from "zod";
+var FunctionCallSchema = z.object({
+  name: z.string(),
+  arguments: z.string()
+});
+var ToolCallSchema = z.object({
+  id: z.string(),
+  type: z.literal("function"),
+  function: FunctionCallSchema
+});
+var BaseMessageSchema = z.object({
+  id: z.string(),
+  role: z.string(),
+  content: z.string().optional(),
+  name: z.string().optional()
+});
+var TextInputContentSchema = z.object({
+  type: z.literal("text"),
+  text: z.string()
+});
+var BinaryInputContentObjectSchema = z.object({
+  type: z.literal("binary"),
+  mimeType: z.string(),
+  id: z.string().optional(),
+  url: z.string().optional(),
+  data: z.string().optional(),
+  filename: z.string().optional()
+});
+var ensureBinaryPayload = (value, ctx) => {
+  if (!value.id && !value.url && !value.data) {
+    ctx.addIssue({
+      code: 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 = z.discriminatedUnion("type", [
+  TextInputContentSchema,
+  BinaryInputContentObjectSchema
+]);
+var InputContentSchema = InputContentBaseSchema.superRefine((value, ctx) => {
+  if (value.type === "binary") {
+    ensureBinaryPayload(value, ctx);
+  }
+});
+var DeveloperMessageSchema = BaseMessageSchema.extend({
+  role: z.literal("developer"),
+  content: z.string()
+});
+var SystemMessageSchema = BaseMessageSchema.extend({
+  role: z.literal("system"),
+  content: z.string()
+});
+var AssistantMessageSchema = BaseMessageSchema.extend({
+  role: z.literal("assistant"),
+  content: z.string().optional(),
+  toolCalls: z.array(ToolCallSchema).optional()
+});
+var UserMessageSchema = BaseMessageSchema.extend({
+  role: z.literal("user"),
+  content: z.union([z.string(), z.array(InputContentSchema)])
+});
+var ToolMessageSchema = z.object({
+  id: z.string(),
+  content: z.string(),
+  role: z.literal("tool"),
+  toolCallId: z.string(),
+  error: z.string().optional()
+});
+var ActivityMessageSchema = z.object({
+  id: z.string(),
+  role: z.literal("activity"),
+  activityType: z.string(),
+  content: z.record(z.any())
+});
+var MessageSchema = z.discriminatedUnion("role", [
+  DeveloperMessageSchema,
+  SystemMessageSchema,
+  AssistantMessageSchema,
+  UserMessageSchema,
+  ToolMessageSchema,
+  ActivityMessageSchema
+]);
+var RoleSchema = z.union([
+  z.literal("developer"),
+  z.literal("system"),
+  z.literal("assistant"),
+  z.literal("user"),
+  z.literal("tool"),
+  z.literal("activity")
+]);
+var ContextSchema = z.object({
+  description: z.string(),
+  value: z.string()
+});
+var ToolSchema = z.object({
+  name: z.string(),
+  description: z.string(),
+  parameters: z.any()
+  // JSON Schema for the tool parameters
+});
+var RunAgentInputSchema = z.object({
+  threadId: z.string(),
+  runId: z.string(),
+  parentRunId: z.string().optional(),
+  state: z.any(),
+  messages: z.array(MessageSchema),
+  tools: z.array(ToolSchema),
+  context: z.array(ContextSchema),
+  forwardedProps: z.any()
+});
+var StateSchema = 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 = z2.union([
+  z2.literal("developer"),
+  z2.literal("system"),
+  z2.literal("assistant"),
+  z2.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 = z2.object({
+  type: z2.nativeEnum(EventType),
+  timestamp: z2.number().optional(),
+  rawEvent: z2.any().optional()
+});
+var TextMessageStartEventSchema = BaseEventSchema.extend({
+  type: z2.literal(
+    "TEXT_MESSAGE_START"
+    /* TEXT_MESSAGE_START */
+  ),
+  messageId: z2.string(),
+  role: TextMessageRoleSchema.default("assistant")
+});
+var TextMessageContentEventSchema = BaseEventSchema.extend({
+  type: z2.literal(
+    "TEXT_MESSAGE_CONTENT"
+    /* TEXT_MESSAGE_CONTENT */
+  ),
+  messageId: z2.string(),
+  delta: z2.string().refine((s) => s.length > 0, "Delta must not be an empty string")
+});
+var TextMessageEndEventSchema = BaseEventSchema.extend({
+  type: z2.literal(
+    "TEXT_MESSAGE_END"
+    /* TEXT_MESSAGE_END */
+  ),
+  messageId: z2.string()
+});
+var TextMessageChunkEventSchema = BaseEventSchema.extend({
+  type: z2.literal(
+    "TEXT_MESSAGE_CHUNK"
+    /* TEXT_MESSAGE_CHUNK */
+  ),
+  messageId: z2.string().optional(),
+  role: TextMessageRoleSchema.optional(),
+  delta: z2.string().optional()
+});
+var ThinkingTextMessageStartEventSchema = BaseEventSchema.extend({
+  type: z2.literal(
+    "THINKING_TEXT_MESSAGE_START"
+    /* THINKING_TEXT_MESSAGE_START */
+  )
+});
+var ThinkingTextMessageContentEventSchema = TextMessageContentEventSchema.omit({
+  messageId: true,
+  type: true
+}).extend({
+  type: z2.literal(
+    "THINKING_TEXT_MESSAGE_CONTENT"
+    /* THINKING_TEXT_MESSAGE_CONTENT */
+  )
+});
+var ThinkingTextMessageEndEventSchema = BaseEventSchema.extend({
+  type: z2.literal(
+    "THINKING_TEXT_MESSAGE_END"
+    /* THINKING_TEXT_MESSAGE_END */
+  )
+});
+var ToolCallStartEventSchema = BaseEventSchema.extend({
+  type: z2.literal(
+    "TOOL_CALL_START"
+    /* TOOL_CALL_START */
+  ),
+  toolCallId: z2.string(),
+  toolCallName: z2.string(),
+  parentMessageId: z2.string().optional()
+});
+var ToolCallArgsEventSchema = BaseEventSchema.extend({
+  type: z2.literal(
+    "TOOL_CALL_ARGS"
+    /* TOOL_CALL_ARGS */
+  ),
+  toolCallId: z2.string(),
+  delta: z2.string()
+});
+var ToolCallEndEventSchema = BaseEventSchema.extend({
+  type: z2.literal(
+    "TOOL_CALL_END"
+    /* TOOL_CALL_END */
+  ),
+  toolCallId: z2.string()
+});
+var ToolCallResultEventSchema = BaseEventSchema.extend({
+  messageId: z2.string(),
+  type: z2.literal(
+    "TOOL_CALL_RESULT"
+    /* TOOL_CALL_RESULT */
+  ),
+  toolCallId: z2.string(),
+  content: z2.string(),
+  role: z2.literal("tool").optional()
+});
+var ToolCallChunkEventSchema = BaseEventSchema.extend({
+  type: z2.literal(
+    "TOOL_CALL_CHUNK"
+    /* TOOL_CALL_CHUNK */
+  ),
+  toolCallId: z2.string().optional(),
+  toolCallName: z2.string().optional(),
+  parentMessageId: z2.string().optional(),
+  delta: z2.string().optional()
+});
+var ThinkingStartEventSchema = BaseEventSchema.extend({
+  type: z2.literal(
+    "THINKING_START"
+    /* THINKING_START */
+  ),
+  title: z2.string().optional()
+});
+var ThinkingEndEventSchema = BaseEventSchema.extend({
+  type: z2.literal(
+    "THINKING_END"
+    /* THINKING_END */
+  )
+});
+var StateSnapshotEventSchema = BaseEventSchema.extend({
+  type: z2.literal(
+    "STATE_SNAPSHOT"
+    /* STATE_SNAPSHOT */
+  ),
+  snapshot: StateSchema
+});
+var StateDeltaEventSchema = BaseEventSchema.extend({
+  type: z2.literal(
+    "STATE_DELTA"
+    /* STATE_DELTA */
+  ),
+  delta: z2.array(z2.any())
+  // JSON Patch (RFC 6902)
+});
+var MessagesSnapshotEventSchema = BaseEventSchema.extend({
+  type: z2.literal(
+    "MESSAGES_SNAPSHOT"
+    /* MESSAGES_SNAPSHOT */
+  ),
+  messages: z2.array(MessageSchema)
+});
+var ActivitySnapshotEventSchema = BaseEventSchema.extend({
+  type: z2.literal(
+    "ACTIVITY_SNAPSHOT"
+    /* ACTIVITY_SNAPSHOT */
+  ),
+  messageId: z2.string(),
+  activityType: z2.string(),
+  content: z2.record(z2.any()),
+  replace: z2.boolean().optional().default(true)
+});
+var ActivityDeltaEventSchema = BaseEventSchema.extend({
+  type: z2.literal(
+    "ACTIVITY_DELTA"
+    /* ACTIVITY_DELTA */
+  ),
+  messageId: z2.string(),
+  activityType: z2.string(),
+  patch: z2.array(z2.any())
+});
+var RawEventSchema = BaseEventSchema.extend({
+  type: z2.literal(
+    "RAW"
+    /* RAW */
+  ),
+  event: z2.any(),
+  source: z2.string().optional()
+});
+var CustomEventSchema = BaseEventSchema.extend({
+  type: z2.literal(
+    "CUSTOM"
+    /* CUSTOM */
+  ),
+  name: z2.string(),
+  value: z2.any()
+});
+var RunStartedEventSchema = BaseEventSchema.extend({
+  type: z2.literal(
+    "RUN_STARTED"
+    /* RUN_STARTED */
+  ),
+  threadId: z2.string(),
+  runId: z2.string(),
+  parentRunId: z2.string().optional(),
+  input: RunAgentInputSchema.optional()
+});
+var RunFinishedEventSchema = BaseEventSchema.extend({
+  type: z2.literal(
+    "RUN_FINISHED"
+    /* RUN_FINISHED */
+  ),
+  threadId: z2.string(),
+  runId: z2.string(),
+  result: z2.any().optional()
+});
+var RunErrorEventSchema = BaseEventSchema.extend({
+  type: z2.literal(
+    "RUN_ERROR"
+    /* RUN_ERROR */
+  ),
+  message: z2.string(),
+  code: z2.string().optional()
+});
+var StepStartedEventSchema = BaseEventSchema.extend({
+  type: z2.literal(
+    "STEP_STARTED"
+    /* STEP_STARTED */
+  ),
+  stepName: z2.string()
+});
+var StepFinishedEventSchema = BaseEventSchema.extend({
+  type: z2.literal(
+    "STEP_FINISHED"
+    /* STEP_FINISHED */
+  ),
+  stepName: z2.string()
+});
+var EventSchemas = z2.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-copilot-chat_internal.ts
+function useConfigureSuggestions(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" };
+  }
+  useConfigureChatSuggestions(suggestionsConfig);
+}
+function useCopilotChatInternal({
+  suggestions
+} = {}) {
+  var _a, _b, _c, _d;
+  const { copilotkit } = useCopilotKit();
+  const { threadId, agentSession } = useCopilotContext();
+  const existingConfig = useCopilotChatConfiguration();
+  const [agentAvailable, setAgentAvailable] = useState(false);
+  useConfigureSuggestions(suggestions);
+  const resolvedAgentId = (_b = (_a = agentSession == null ? void 0 : agentSession.agentName) != null ? _a : existingConfig == null ? void 0 : existingConfig.agentId) != null ? _b : "default";
+  const { agent } = useAgent({ agentId: resolvedAgentId });
+  useEffect(() => {
+    const connect = (agent2) => __async(this, null, function* () {
+      setAgentAvailable(false);
+      try {
+        yield copilotkit.connectAgent({ agent: agent2 });
+        setAgentAvailable(true);
+      } catch (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);
+    }
+    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 = useCallback(
+    (messageId) => {
+      var _a2;
+      const filteredMessages = ((_a2 = agent == null ? void 0 : agent.messages) != null ? _a2 : []).filter(
+        (message) => message.id !== messageId
+      );
+      agent == null ? void 0 : agent.setMessages(filteredMessages);
+    },
+    [agent == null ? void 0 : agent.setMessages, agent == null ? void 0 : agent.messages]
+  );
+  const latestDelete = useUpdatedRef(deleteMessage);
+  const latestDeleteFunc = useCallback(
+    (messageId) => {
+      return latestDelete.current(messageId);
+    },
+    [latestDelete]
+  );
+  const currentSuggestions = 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;
+      }
+      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 !== "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]];
+      }
+      agent == null ? void 0 : agent.setMessages(historyCutoff);
+      if (agent) {
+        copilotkit.runAgent({ agent });
+      }
+      return;
+    }),
+    [agent == null ? void 0 : agent.setMessages, copilotkit == null ? void 0 : copilotkit.runAgent]
+  );
+  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 latestAppendFunc = useAsyncCallback(
+    (message, options) => __async(this, null, function* () {
+      return latestSendMessageFunc(gqlToAGUI([message])[0], options);
+    }),
+    [latestSendMessageFunc]
+  );
+  const latestSetMessages = useUpdatedRef(agent == null ? void 0 : agent.setMessages);
+  const latestSetMessagesFunc = useCallback(
+    (messages) => {
+      var _a2, _b2;
+      if (messages.every((message) => message instanceof DeprecatedGqlMessage)) {
+        return (_a2 = latestSetMessages.current) == null ? void 0 : _a2.call(latestSetMessages, gqlToAGUI(messages));
+      }
+      return (_b2 = latestSetMessages.current) == null ? void 0 : _b2.call(latestSetMessages, messages);
+    },
+    [latestSetMessages, agent]
+  );
+  const latestReload = useUpdatedRef(reload);
+  const latestReloadFunc = useAsyncCallback(
+    (messageId) => __async(this, null, function* () {
+      return yield latestReload.current(messageId);
+    }),
+    [latestReload]
+  );
+  const latestStop = useUpdatedRef(agent == null ? void 0 : agent.abortRun);
+  const latestStopFunc = useCallback(() => {
+    var _a2;
+    return (_a2 = latestStop.current) == null ? void 0 : _a2.call(latestStop);
+  }, [latestStop]);
+  const latestReset = useUpdatedRef(reset);
+  const latestResetFunc = useCallback(() => {
+    return latestReset.current();
+  }, [latestReset]);
+  const lazyToolRendered = useLazyToolRenderer();
+  const renderCustomMessage = 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 = useMemo(() => {
+    let processedMessages = allMessages.map((message) => {
+      if (message.role !== "assistant") {
+        return message;
+      }
+      const lazyRendered = lazyToolRendered(message, allMessages);
+      if (lazyRendered) {
+        const renderedGenUi = lazyRendered();
+        if (renderedGenUi) {
+          return __spreadProps(__spreadValues({}, message), { generativeUI: () => renderedGenUi });
+        }
+      }
+      const bridgeRenderer = legacyCustomMessageRenderer || renderCustomMessage ? () => {
+        const customRender = renderCustomMessage == null ? void 0 : renderCustomMessage({
+          message,
+          position: "before"
+        });
+        if (customRender) {
+          return customRender;
+        }
+        return legacyCustomMessageRenderer == null ? void 0 : legacyCustomMessageRenderer({ message, position: "before" });
+      } : null;
+      if (bridgeRenderer) {
+        return __spreadProps(__spreadValues({}, message), { generativeUI: bridgeRenderer });
+      }
+      return message;
+    });
+    const hasAssistantMessages = processedMessages.some((msg) => msg.role === "assistant");
+    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"
+          })
+        })
+      ];
+    }
+    return processedMessages;
+  }, [
+    agent == null ? void 0 : agent.messages,
+    lazyToolRendered,
+    allMessages,
+    renderCustomMessage,
+    legacyCustomMessageRenderer,
+    resolvedAgentId
+  ]);
+  return {
+    messages: resolvedMessages,
+    sendMessage: latestSendMessageFunc,
+    appendMessage: latestAppendFunc,
+    setMessages: latestSetMessagesFunc,
+    reloadMessages: latestReloadFunc,
+    stopGeneration: latestStopFunc,
+    reset: latestResetFunc,
+    deleteMessage: latestDeleteFunc,
+    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 = useRef(value);
+  useEffect(() => {
+    ref.current = value;
+  }, [value]);
+  return ref;
+}
+function useLegacyCoagentRenderer({
+  copilotkit,
+  agent,
+  agentId,
+  threadId
+}) {
+  return 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 createElement(CoAgentStateRenderBridge, bridgeProps);
+    };
+  }, [agent, agentId, copilotkit, threadId]);
+}
+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}` : "");
+}
+
+export {
+  useCopilotChatInternal,
+  defaultSystemMessage
+};
+//# sourceMappingURL=chunk-UJBV5GAG.mjs.map