@copilotkit/react-core 1.10.6 → 1.50.0-beta.0

package/src/utils/extract.ts

@@ -1,215 +0,0 @@
-import {
-  Action,
-  COPILOT_CLOUD_PUBLIC_API_KEY_HEADER,
-  MappedParameterTypes,
-  Parameter,
-  actionParametersToJsonSchema,
-} from "@copilotkit/shared";
-import {
-  ActionExecutionMessage,
-  Message,
-  Role,
-  TextMessage,
-  convertGqlOutputToMessages,
-  CopilotRequestType,
-  ForwardedParametersInput,
-} from "@copilotkit/runtime-client-gql";
-import { CopilotContextParams, CopilotMessagesContextParams } from "../context";
-import { defaultCopilotContextCategories } from "../components";
-import { CopilotRuntimeClient } from "@copilotkit/runtime-client-gql";
-import {
-  convertMessagesToGqlInput,
-  filterAgentStateMessages,
-} from "@copilotkit/runtime-client-gql";
-
-interface InitialState<T extends Parameter[] | [] = []> {
-  status: "initial";
-  args: Partial<MappedParameterTypes<T>>;
-}
-
-interface InProgressState<T extends Parameter[] | [] = []> {
-  status: "inProgress";
-  args: Partial<MappedParameterTypes<T>>;
-}
-
-interface CompleteState<T extends Parameter[] | [] = []> {
-  status: "complete";
-  args: MappedParameterTypes<T>;
-}
-
-type StreamHandlerArgs<T extends Parameter[] | [] = []> =
-  | InitialState<T>
-  | InProgressState<T>
-  | CompleteState<T>;
-
-interface ExtractOptions<T extends Parameter[]> {
-  context: CopilotContextParams & CopilotMessagesContextParams;
-  instructions: string;
-  parameters: T;
-  include?: IncludeOptions;
-  data?: any;
-  abortSignal?: AbortSignal;
-  stream?: (args: StreamHandlerArgs<T>) => void;
-  requestType?: CopilotRequestType;
-  forwardedParameters?: ForwardedParametersInput;
-}
-
-interface IncludeOptions {
-  readable?: boolean;
-  messages?: boolean;
-}
-
-export async function extract<const T extends Parameter[]>({
-  context,
-  instructions,
-  parameters,
-  include,
-  data,
-  abortSignal,
-  stream,
-  requestType = CopilotRequestType.Task,
-  forwardedParameters,
-}: ExtractOptions<T>): Promise<MappedParameterTypes<T>> {
-  const { messages } = context;
-
-  const action: Action<any> = {
-    name: "extract",
-    description: instructions,
-    parameters,
-    handler: (args: any) => {},
-  };
-
-  const includeReadable = include?.readable ?? false;
-  const includeMessages = include?.messages ?? false;
-
-  let contextString = "";
-
-  if (data) {
-    contextString = (typeof data === "string" ? data : JSON.stringify(data)) + "\n\n";
-  }
-
-  if (includeReadable) {
-    contextString += context.getContextString([], defaultCopilotContextCategories);
-  }
-
-  const systemMessage: Message = new TextMessage({
-    content: makeSystemMessage(contextString, instructions),
-    role: Role.System,
-  });
-
-  const instructionsMessage: Message = new TextMessage({
-    content: makeInstructionsMessage(instructions),
-    role: Role.User,
-  });
-
-  const response = context.runtimeClient.asStream(
-    context.runtimeClient.generateCopilotResponse({
-      data: {
-        frontend: {
-          actions: [
-            {
-              name: action.name,
-              description: action.description || "",
-              jsonSchema: JSON.stringify(actionParametersToJsonSchema(action.parameters || [])),
-            },
-          ],
-          url: window.location.href,
-        },
-
-        messages: convertMessagesToGqlInput(
-          includeMessages
-            ? [systemMessage, instructionsMessage, ...filterAgentStateMessages(messages)]
-            : [systemMessage, instructionsMessage],
-        ),
-        metadata: {
-          requestType: requestType,
-        },
-        forwardedParameters: {
-          ...(forwardedParameters ?? {}),
-          toolChoice: "function",
-          toolChoiceFunctionName: action.name,
-        },
-      },
-      properties: context.copilotApiConfig.properties,
-      signal: abortSignal,
-    }),
-  );
-
-  const reader = response.getReader();
-
-  let isInitial = true;
-
-  let actionExecutionMessage: ActionExecutionMessage | undefined = undefined;
-
-  while (true) {
-    const { done, value } = await reader.read();
-
-    if (done) {
-      break;
-    }
-
-    if (abortSignal?.aborted) {
-      throw new Error("Aborted");
-    }
-
-    actionExecutionMessage = convertGqlOutputToMessages(
-      value.generateCopilotResponse.messages,
-    ).find((msg) => msg.isActionExecutionMessage()) as ActionExecutionMessage | undefined;
-
-    if (!actionExecutionMessage) {
-      continue;
-    }
-
-    stream?.({
-      status: isInitial ? "initial" : "inProgress",
-      args: actionExecutionMessage.arguments as Partial<MappedParameterTypes<T>>,
-    });
-
-    isInitial = false;
-  }
-
-  if (!actionExecutionMessage) {
-    throw new Error("extract() failed: No function call occurred");
-  }
-
-  stream?.({
-    status: "complete",
-    args: actionExecutionMessage.arguments as MappedParameterTypes<T>,
-  });
-
-  return actionExecutionMessage.arguments as MappedParameterTypes<T>;
-}
-
-// We need to put this in a user message since some LLMs need
-// at least one user message to function
-function makeInstructionsMessage(instructions: string): string {
-  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.
-`;
-}
-
-function makeSystemMessage(contextString: string, instructions: string): string {
-  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.
-`;
-}

package/src/utils/suggestions.ts

@@ -1,208 +0,0 @@
-/**
- * Suggestions utility functions for CopilotKit
- *
- * This module handles the generation of chat suggestions with optimized error handling
- * and streaming validation to prevent infinite retry loops and console spam.
- */
-
-import { extract } from "./extract";
-import { actionParametersToJsonSchema } from "@copilotkit/shared";
-import { CopilotRequestType } from "@copilotkit/runtime-client-gql";
-import { CopilotContextParams, CopilotMessagesContextParams } from "../context";
-import { CopilotChatSuggestionConfiguration } from "../types";
-
-export interface SuggestionItem {
-  title: string;
-  message: string;
-  partial?: boolean;
-  className?: string;
-}
-
-export const reloadSuggestions = async (
-  context: CopilotContextParams & CopilotMessagesContextParams,
-  chatSuggestionConfiguration: { [key: string]: CopilotChatSuggestionConfiguration },
-  setCurrentSuggestions: (suggestions: SuggestionItem[]) => void,
-  abortControllerRef: React.MutableRefObject<AbortController | null>,
-): Promise<void> => {
-  const abortController = abortControllerRef.current;
-
-  // Early abort check
-  if (abortController?.signal.aborted) {
-    return;
-  }
-
-  // Abort-aware suggestion setter with safety checks to prevent race conditions
-  const setSuggestionsIfNotAborted = (suggestions: SuggestionItem[]) => {
-    if (!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(actionParametersToJsonSchema(action.parameters)),
-      })),
-    );
-
-    const allSuggestions: SuggestionItem[] = [];
-    let hasSuccessfulSuggestions = false;
-    let hasErrors = false; // Track if any errors occurred
-    let lastError: Error | null = null; // Track the last error for better error reporting
-
-    // Get enabled configurations
-    const enabledConfigs = Object.values(chatSuggestionConfiguration).filter(
-      (config) => config.instructions && config.instructions.trim().length > 0,
-    );
-
-    if (enabledConfigs.length === 0) {
-      return;
-    }
-
-    // Clear existing suggestions
-    setSuggestionsIfNotAborted([]);
-
-    // Generate suggestions for each configuration
-    for (const config of enabledConfigs) {
-      // Check if aborted before each configuration
-      if (abortController?.signal.aborted) {
-        setSuggestionsIfNotAborted([]);
-        return;
-      }
-
-      try {
-        const result = await extract({
-          context,
-          instructions:
-            "Suggest what the user could say next. Provide clear, highly relevant suggestions. Do not literally suggest function calls. ",
-          data: `${config.instructions}\n\nAvailable tools: ${tools}\n\n`,
-          requestType: 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?.signal,
-          stream: ({ status, args }: { status: string; args: any }) => {
-            // Check abort status in stream callback
-            if (abortController?.signal.aborted) {
-              return;
-            }
-
-            const suggestions = args.suggestions || [];
-            const newSuggestions: SuggestionItem[] = [];
-
-            for (let i = 0; i < suggestions.length; i++) {
-              // Respect max suggestions limit
-              if (config.maxSuggestions !== undefined && i >= config.maxSuggestions) {
-                break;
-              }
-
-              const suggestion = suggestions[i];
-
-              // Skip completely empty or invalid objects during streaming
-              if (!suggestion || typeof suggestion !== "object") {
-                continue;
-              }
-
-              const { title, message } = suggestion;
-
-              // During streaming, be permissive but require at least a meaningful title
-              const hasValidTitle = title && typeof title === "string" && title.trim().length > 0;
-              const hasValidMessage =
-                message && typeof message === "string" && message.trim().length > 0;
-
-              // During streaming, we need at least a title to show something useful
-              if (!hasValidTitle) {
-                continue;
-              }
-
-              // Mark as partial if this is the last suggestion and streaming isn't complete
-              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,
-              });
-            }
-
-            // Update suggestions with current batch
-            setSuggestionsIfNotAborted([...allSuggestions, ...newSuggestions]);
-          },
-        });
-
-        // Process final results with strict validation
-        if (result?.suggestions && Array.isArray(result.suggestions)) {
-          const validSuggestions = result.suggestions
-            .filter(
-              (suggestion: any) =>
-                suggestion &&
-                typeof suggestion.title === "string" &&
-                suggestion.title.trim().length > 0,
-            )
-            .map((suggestion: any) => ({
-              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;
-          }
-        }
-      } catch (error) {
-        // Simple error handling - just continue with next config, don't log here
-        hasErrors = true;
-        lastError = error instanceof Error ? error : new Error(String(error));
-      }
-    }
-
-    // Display any successful suggestions we got
-    if (hasSuccessfulSuggestions && allSuggestions.length > 0) {
-      // Remove duplicates based on message content
-      const uniqueSuggestions = allSuggestions.filter(
-        (suggestion, index, self) =>
-          index === self.findIndex((s) => s.message === suggestion.message),
-      );
-
-      setSuggestionsIfNotAborted(uniqueSuggestions);
-    } else if (hasErrors) {
-      // If we had errors but no successful suggestions, throw an error with details
-      const errorMessage = lastError
-        ? lastError.message
-        : "Failed to generate suggestions due to API errors";
-      throw new Error(errorMessage);
-    }
-  } catch (error) {
-    // Top-level error handler - re-throw to allow caller to handle
-    throw error;
-  }
-};