@copilotkit/react-core 0.0.0-feat-dynamic-copilotcloud-qa-20250117190454

package/src/types/chat-suggestion-configuration.ts

@@ -0,0 +1,23 @@
+export interface CopilotChatSuggestionConfiguration {
+  /**
+   * A prompt or instructions for the GPT to generate suggestions.
+   */
+  instructions: string;
+
+  /**
+   * The minimum number of suggestions to generate. Defaults to `1`.
+   * @default 1
+   */
+  minSuggestions?: number;
+
+  /**
+   * The maximum number of suggestions to generate. Defaults to `3`.
+   * @default 1
+   */
+  maxSuggestions?: number;
+
+  /**
+   * An optional class name to apply to the suggestions.
+   */
+  className?: string;
+}

package/src/types/coagent-action.ts

@@ -0,0 +1,31 @@
+export type CoAgentStateRenderProps<T> = {
+  state: T;
+  nodeName: string;
+  status: "inProgress" | "complete";
+};
+
+export type CoAgentStateRenderHandlerArguments<T> = {
+  nodeName: string;
+  state: T;
+};
+
+export interface CoAgentStateRender<T = any> {
+  /**
+   * The name of the coagent.
+   */
+  name: string;
+  /**
+   * The node name of the coagent.
+   */
+  nodeName?: string;
+  /**
+   * The handler function to handle the state of the agent.
+   */
+  handler?: (props: CoAgentStateRenderHandlerArguments<T>) => void | Promise<void>;
+  /**
+   * The render function to handle the state of the agent.
+   */
+  render?:
+    | ((props: CoAgentStateRenderProps<T>) => string | React.ReactElement | undefined | null)
+    | string;
+}

package/src/types/coagent-state.ts

@@ -0,0 +1,9 @@
+export interface CoagentState {
+  name: string;
+  state: any;
+  running: boolean;
+  active: boolean;
+  threadId?: string;
+  nodeName?: string;
+  runId?: string;
+}

package/src/types/document-pointer.ts

@@ -0,0 +1,7 @@
+export interface DocumentPointer {
+  id: string;
+  name: string;
+  sourceApplication: string;
+  iconImageUri: string;
+  getContents: () => string;
+}

package/src/types/frontend-action.ts

@@ -0,0 +1,199 @@
+import { ActionInputAvailability } from "@copilotkit/runtime-client-gql";
+import {
+  Action,
+  Parameter,
+  MappedParameterTypes,
+  actionParametersToJsonSchema,
+} from "@copilotkit/shared";
+import React from "react";
+
+interface InProgressState<T extends Parameter[] | [] = []> {
+  status: "inProgress";
+  args: Partial<MappedParameterTypes<T>>;
+  result: undefined;
+}
+
+interface ExecutingState<T extends Parameter[] | [] = []> {
+  status: "executing";
+  args: MappedParameterTypes<T>;
+  result: undefined;
+}
+
+interface CompleteState<T extends Parameter[] | [] = []> {
+  status: "complete";
+  args: MappedParameterTypes<T>;
+  result: any;
+}
+
+interface InProgressStateNoArgs<T extends Parameter[] | [] = []> {
+  status: "inProgress";
+  args: Partial<MappedParameterTypes<T>>;
+  result: undefined;
+}
+
+interface ExecutingStateNoArgs<T extends Parameter[] | [] = []> {
+  status: "executing";
+  args: MappedParameterTypes<T>;
+  result: undefined;
+}
+
+interface CompleteStateNoArgs<T extends Parameter[] | [] = []> {
+  status: "complete";
+  args: MappedParameterTypes<T>;
+  result: any;
+}
+
+interface InProgressStateWait<T extends Parameter[] | [] = []> {
+  status: "inProgress";
+  args: Partial<MappedParameterTypes<T>>;
+  /** @deprecated use respond instead */
+  handler: undefined;
+  respond: undefined;
+  result: undefined;
+}
+
+interface ExecutingStateWait<T extends Parameter[] | [] = []> {
+  status: "executing";
+  args: MappedParameterTypes<T>;
+  /** @deprecated use respond instead */
+  handler: (result: any) => void;
+  respond: (result: any) => void;
+  result: undefined;
+}
+
+interface CompleteStateWait<T extends Parameter[] | [] = []> {
+  status: "complete";
+  args: MappedParameterTypes<T>;
+  /** @deprecated use respond instead */
+  handler: undefined;
+  respond: undefined;
+  result: any;
+}
+
+interface InProgressStateNoArgsWait<T extends Parameter[] | [] = []> {
+  status: "inProgress";
+  args: Partial<MappedParameterTypes<T>>;
+  /** @deprecated use respond instead */
+  handler: undefined;
+  respond: undefined;
+  result: undefined;
+}
+
+interface ExecutingStateNoArgsWait<T extends Parameter[] | [] = []> {
+  status: "executing";
+  args: MappedParameterTypes<T>;
+  /** @deprecated use respond instead */
+  handler: (result: any) => void;
+  respond: (result: any) => void;
+  result: undefined;
+}
+
+interface CompleteStateNoArgsWait<T extends Parameter[] | [] = []> {
+  status: "complete";
+  args: MappedParameterTypes<T>;
+  /** @deprecated use respond instead */
+  handler: undefined;
+  respond: undefined;
+}
+
+export type ActionRenderProps<T extends Parameter[] | [] = []> =
+  | CompleteState<T>
+  | ExecutingState<T>
+  | InProgressState<T>;
+
+export type ActionRenderPropsNoArgs<T extends Parameter[] | [] = []> =
+  | CompleteStateNoArgs<T>
+  | ExecutingStateNoArgs<T>
+  | InProgressStateNoArgs<T>;
+
+export type ActionRenderPropsWait<T extends Parameter[] | [] = []> =
+  | CompleteStateWait<T>
+  | ExecutingStateWait<T>
+  | InProgressStateWait<T>;
+
+export type ActionRenderPropsNoArgsWait<T extends Parameter[] | [] = []> =
+  | CompleteStateNoArgsWait<T>
+  | ExecutingStateNoArgsWait<T>
+  | InProgressStateNoArgsWait<T>;
+
+export type CatchAllActionRenderProps<T extends Parameter[] | [] = []> =
+  | (CompleteState<T> & {
+      name: string;
+    })
+  | (ExecutingState<T> & {
+      name: string;
+    })
+  | (InProgressState<T> & {
+      name: string;
+    });
+
+export type FrontendActionAvailability = "disabled" | "enabled" | "remote";
+
+export type FrontendAction<
+  T extends Parameter[] | [] = [],
+  N extends string = string,
+> = Action<T> & {
+  name: Exclude<N, "*">;
+  /**
+   * @deprecated Use `available` instead.
+   */
+  disabled?: boolean;
+  available?: FrontendActionAvailability;
+  followUp?: boolean;
+} & (
+    | {
+        render?:
+          | string
+          | (T extends []
+              ? (props: ActionRenderPropsNoArgs<T>) => string | React.ReactElement
+              : (props: ActionRenderProps<T>) => string | React.ReactElement);
+        /** @deprecated use renderAndWaitForResponse instead */
+        renderAndWait?: never;
+        renderAndWaitForResponse?: never;
+      }
+    | {
+        render?: never;
+        /** @deprecated use renderAndWaitForResponse instead */
+        renderAndWait?: T extends []
+          ? (props: ActionRenderPropsNoArgsWait<T>) => React.ReactElement
+          : (props: ActionRenderPropsWait<T>) => React.ReactElement;
+        renderAndWaitForResponse?: T extends []
+          ? (props: ActionRenderPropsNoArgsWait<T>) => React.ReactElement
+          : (props: ActionRenderPropsWait<T>) => React.ReactElement;
+        handler?: never;
+      }
+  );
+
+export type CatchAllFrontendAction = {
+  name: "*";
+  render: (props: CatchAllActionRenderProps<any>) => React.ReactElement;
+};
+
+export type RenderFunctionStatus = ActionRenderProps<any>["status"];
+
+export function processActionsForRuntimeRequest(actions: FrontendAction<any>[]) {
+  const filteredActions = actions
+    .filter(
+      (action) =>
+        action.available !== ActionInputAvailability.Disabled &&
+        action.disabled !== true &&
+        action.name !== "*",
+    )
+    .map((action) => {
+      let available: ActionInputAvailability | undefined = ActionInputAvailability.Enabled;
+      if (action.disabled) {
+        available = ActionInputAvailability.Disabled;
+      } else if (action.available === "disabled") {
+        available = ActionInputAvailability.Disabled;
+      } else if (action.available === "remote") {
+        available = ActionInputAvailability.Remote;
+      }
+      return {
+        name: action.name,
+        description: action.description || "",
+        jsonSchema: JSON.stringify(actionParametersToJsonSchema(action.parameters || [])),
+        available,
+      };
+    });
+  return filteredActions;
+}

package/src/types/index.ts

@@ -0,0 +1,8 @@
+export type { DocumentPointer } from "./document-pointer";
+export type { SystemMessageFunction } from "./system-message";
+export type {
+  ActionRenderProps,
+  RenderFunctionStatus,
+  CatchAllActionRenderProps,
+} from "./frontend-action";
+export type { CopilotChatSuggestionConfiguration } from "./chat-suggestion-configuration";

package/src/types/system-message.ts

@@ -0,0 +1,4 @@
+export type SystemMessageFunction = (
+  contextString: string,
+  additionalInstructions?: string,
+) => string;

package/src/utils/dev-console.ts

@@ -0,0 +1,18 @@
+export function shouldShowDevConsole(showDevConsole: boolean | "auto"): boolean {
+  if (typeof showDevConsole === "boolean") {
+    return showDevConsole;
+  }
+  return (
+    getHostname() === "localhost" ||
+    getHostname() === "127.0.0.1" ||
+    getHostname() === "0.0.0.0" ||
+    getHostname() === "::1"
+  );
+}
+
+function getHostname(): string {
+  if (typeof window !== "undefined" && window.location) {
+    return window.location.hostname;
+  }
+  return "";
+}

package/src/utils/extract.ts

@@ -0,0 +1,215 @@
+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/index.ts

@@ -0,0 +1,2 @@
+export { extract } from "./extract";
+export * from "./dev-console";

package/src/utils/utils.test.ts

@@ -0,0 +1,7 @@
+import * as utils from "./utils";
+
+describe("emptyTest", () => {
+  it("should be truthy", () => {
+    expect(true).toBeTruthy();
+  });
+});

package/src/utils/utils.ts

@@ -0,0 +1 @@
+export {};

package/tsconfig.json

@@ -0,0 +1,12 @@
+{
+  "extends": "../../utilities/tsconfig/react-library.json",
+  "include": ["."],
+  "exclude": [
+    "dist",
+    "build",
+    "node_modules",
+    "**/*.test.ts", 
+    "**/*.test.tsx",
+    "**/__tests__/*"
+  ]
+}

package/tsup.config.ts

@@ -0,0 +1,16 @@
+import { defineConfig, Options } from "tsup";
+
+export default defineConfig((options: Options) => ({
+  entry: ["src/**/*.{ts,tsx}"],
+  format: ["esm", "cjs"],
+  dts: true,
+  minify: false,
+  external: ["react"],
+  sourcemap: true,
+  exclude: [
+    "**/*.test.ts", // Exclude TypeScript test files
+    "**/*.test.tsx", // Exclude TypeScript React test files
+    "**/__tests__/*", // Exclude any files inside a __tests__ directory
+  ],
+  ...options,
+}));

package/typedoc.json

@@ -0,0 +1,4 @@
+{
+  "extends": ["../../typedoc.base.json"],
+  "entryPoints": ["src/index.tsx"]
+}