@copilotkit/runtime 0.0.0-feat-dynamic-copilotcloud-qa-20250117190454

package/src/graphql/types/converted/index.ts

@@ -0,0 +1,136 @@
+import {
+  ActionExecutionMessageInput,
+  ResultMessageInput,
+  TextMessageInput,
+  AgentStateMessageInput,
+} from "../../inputs/message.input";
+import { BaseMessageInput } from "../base";
+import { MessageRole } from "../enums";
+
+export type MessageType =
+  | "TextMessage"
+  | "ActionExecutionMessage"
+  | "ResultMessage"
+  | "AgentStateMessage";
+
+export class Message extends BaseMessageInput {
+  type: MessageType;
+
+  isTextMessage(): this is TextMessage {
+    return this.type === "TextMessage";
+  }
+
+  isActionExecutionMessage(): this is ActionExecutionMessage {
+    return this.type === "ActionExecutionMessage";
+  }
+
+  isResultMessage(): this is ResultMessage {
+    return this.type === "ResultMessage";
+  }
+
+  isAgentStateMessage(): this is AgentStateMessage {
+    return this.type === "AgentStateMessage";
+  }
+}
+
+export class TextMessage extends Message implements TextMessageInput {
+  type: MessageType = "TextMessage";
+  content: string;
+  role: MessageRole;
+  parentMessageId?: string;
+}
+
+export class ActionExecutionMessage
+  extends Message
+  implements Omit<ActionExecutionMessageInput, "arguments" | "scope">
+{
+  type: MessageType = "ActionExecutionMessage";
+  name: string;
+  arguments: Record<string, any>;
+  parentMessageId?: string;
+}
+
+export class ResultMessage extends Message implements ResultMessageInput {
+  type: MessageType = "ResultMessage";
+  actionExecutionId: string;
+  actionName: string;
+  result: string;
+
+  static encodeResult(
+    result: any,
+    error?: { code: string; message: string } | string | Error,
+  ): string {
+    const errorObj = error
+      ? typeof error === "string"
+        ? { code: "ERROR", message: error }
+        : error instanceof Error
+          ? { code: "ERROR", message: error.message }
+          : error
+      : undefined;
+
+    if (errorObj) {
+      return JSON.stringify({
+        error: errorObj,
+        result: result || "",
+      });
+    }
+    if (result === undefined) {
+      return "";
+    }
+    return typeof result === "string" ? result : JSON.stringify(result);
+  }
+
+  static decodeResult(result: string): {
+    error?: { code: string; message: string };
+    result: string;
+  } {
+    if (!result) {
+      return { result: "" };
+    }
+    try {
+      const parsed = JSON.parse(result);
+      if (parsed && typeof parsed === "object") {
+        if ("error" in parsed) {
+          return {
+            error: parsed.error,
+            result: parsed.result || "",
+          };
+        }
+        return { result: JSON.stringify(parsed) };
+      }
+      return { result };
+    } catch (e) {
+      return { result };
+    }
+  }
+
+  hasError(): boolean {
+    try {
+      const { error } = ResultMessage.decodeResult(this.result);
+      return !!error;
+    } catch {
+      return false;
+    }
+  }
+
+  getError(): { code: string; message: string } | undefined {
+    try {
+      const { error } = ResultMessage.decodeResult(this.result);
+      return error;
+    } catch {
+      return undefined;
+    }
+  }
+}
+
+export class AgentStateMessage extends Message implements Omit<AgentStateMessageInput, "state"> {
+  type: MessageType = "AgentStateMessage";
+  threadId: string;
+  agentName: string;
+  nodeName: string;
+  runId: string;
+  active: boolean;
+  role: MessageRole;
+  state: any;
+  running: boolean;
+}

package/src/graphql/types/copilot-response.type.ts

@@ -0,0 +1,113 @@
+import { Field, InterfaceType, ObjectType } from "type-graphql";
+import { MessageRole } from "./enums";
+import { MessageStatusUnion } from "./message-status.type";
+import { ResponseStatusUnion } from "./response-status.type";
+
+@InterfaceType({
+  resolveType(value) {
+    if (value.hasOwnProperty("content")) {
+      return TextMessageOutput;
+    } else if (value.hasOwnProperty("name")) {
+      return ActionExecutionMessageOutput;
+    } else if (value.hasOwnProperty("result")) {
+      return ResultMessageOutput;
+    } else if (value.hasOwnProperty("state")) {
+      return AgentStateMessageOutput;
+    }
+    return undefined;
+  },
+})
+abstract class BaseMessageOutput {
+  @Field(() => String)
+  id: string;
+
+  @Field(() => Date)
+  createdAt: Date;
+
+  @Field(() => MessageStatusUnion)
+  status: typeof MessageStatusUnion;
+}
+
+@ObjectType({ implements: BaseMessageOutput })
+export class TextMessageOutput {
+  @Field(() => MessageRole)
+  role: MessageRole;
+
+  @Field(() => [String])
+  content: string[];
+
+  @Field(() => String, { nullable: true })
+  parentMessageId?: string;
+}
+
+@ObjectType({ implements: BaseMessageOutput })
+export class ActionExecutionMessageOutput {
+  @Field(() => String)
+  name: string;
+
+  @Field(() => String, {
+    nullable: true,
+    deprecationReason: "This field will be removed in a future version",
+  })
+  scope?: string;
+
+  @Field(() => [String])
+  arguments: string[];
+
+  @Field(() => String, { nullable: true })
+  parentMessageId?: string;
+}
+
+@ObjectType({ implements: BaseMessageOutput })
+export class ResultMessageOutput {
+  @Field(() => String)
+  actionExecutionId: string;
+
+  @Field(() => String)
+  actionName: string;
+
+  @Field(() => String)
+  result: string;
+}
+
+@ObjectType({ implements: BaseMessageOutput })
+export class AgentStateMessageOutput {
+  @Field(() => String)
+  threadId: string;
+
+  @Field(() => String)
+  agentName: string;
+
+  @Field(() => String)
+  nodeName: string;
+
+  @Field(() => String)
+  runId: string;
+
+  @Field(() => Boolean)
+  active: boolean;
+
+  @Field(() => MessageRole)
+  role: MessageRole;
+
+  @Field(() => String)
+  state: string;
+
+  @Field(() => Boolean)
+  running: boolean;
+}
+
+@ObjectType()
+export class CopilotResponse {
+  @Field(() => String)
+  threadId!: string;
+
+  @Field(() => ResponseStatusUnion)
+  status: typeof ResponseStatusUnion;
+
+  @Field({ nullable: true })
+  runId?: string;
+
+  @Field(() => [BaseMessageOutput])
+  messages: (typeof BaseMessageOutput)[];
+}

package/src/graphql/types/enums.ts

@@ -0,0 +1,37 @@
+import { registerEnumType } from "type-graphql";
+
+export enum MessageRole {
+  user = "user",
+  assistant = "assistant",
+  system = "system",
+  tool = "tool",
+}
+
+export enum CopilotRequestType {
+  Chat = "Chat",
+  Task = "Task",
+  TextareaCompletion = "TextareaCompletion",
+  TextareaPopover = "TextareaPopover",
+  Suggestion = "Suggestion",
+}
+
+export enum ActionInputAvailability {
+  disabled = "disabled",
+  enabled = "enabled",
+  remote = "remote",
+}
+
+registerEnumType(MessageRole, {
+  name: "MessageRole",
+  description: "The role of the message",
+});
+
+registerEnumType(CopilotRequestType, {
+  name: "CopilotRequestType",
+  description: "The type of Copilot request",
+});
+
+registerEnumType(ActionInputAvailability, {
+  name: "ActionInputAvailability",
+  description: "The availability of the frontend action",
+});

package/src/graphql/types/guardrails-result.type.ts

@@ -0,0 +1,20 @@
+import { Field, ObjectType, registerEnumType } from "type-graphql";
+
+export enum GuardrailsResultStatus {
+  ALLOWED = "allowed",
+  DENIED = "denied",
+}
+
+registerEnumType(GuardrailsResultStatus, {
+  name: "GuardrailsResultStatus",
+  description: "The status of the guardrails check",
+});
+
+@ObjectType()
+export class GuardrailsResult {
+  @Field(() => GuardrailsResultStatus)
+  status: GuardrailsResultStatus;
+
+  @Field(() => String, { nullable: true })
+  reason?: string;
+}

package/src/graphql/types/message-status.type.ts

@@ -0,0 +1,40 @@
+import { Field, ObjectType, createUnionType, registerEnumType } from "type-graphql";
+
+export enum MessageStatusCode {
+  Pending = "pending",
+  Success = "success",
+  Failed = "failed",
+}
+
+registerEnumType(MessageStatusCode, {
+  name: "MessageStatusCode",
+});
+
+@ObjectType()
+class BaseMessageStatus {
+  @Field(() => MessageStatusCode)
+  code: MessageStatusCode;
+}
+
+@ObjectType()
+export class PendingMessageStatus extends BaseMessageStatus {
+  code: MessageStatusCode = MessageStatusCode.Pending;
+}
+
+@ObjectType()
+export class SuccessMessageStatus extends BaseMessageStatus {
+  code: MessageStatusCode = MessageStatusCode.Success;
+}
+
+@ObjectType()
+export class FailedMessageStatus extends BaseMessageStatus {
+  code: MessageStatusCode = MessageStatusCode.Failed;
+
+  @Field(() => String)
+  reason: string;
+}
+
+export const MessageStatusUnion = createUnionType({
+  name: "MessageStatus",
+  types: () => [PendingMessageStatus, SuccessMessageStatus, FailedMessageStatus] as const,
+});

package/src/graphql/types/response-status.type.ts

@@ -0,0 +1,66 @@
+import { GraphQLJSON } from "graphql-scalars";
+import { Field, InterfaceType, ObjectType, createUnionType, registerEnumType } from "type-graphql";
+
+export enum ResponseStatusCode {
+  Pending = "pending",
+  Success = "success",
+  Failed = "failed",
+}
+
+registerEnumType(ResponseStatusCode, {
+  name: "ResponseStatusCode",
+});
+
+@InterfaceType({
+  resolveType(value) {
+    if (value.code === ResponseStatusCode.Success) {
+      return SuccessResponseStatus;
+    } else if (value.code === ResponseStatusCode.Failed) {
+      return FailedResponseStatus;
+    } else if (value.code === ResponseStatusCode.Pending) {
+      return PendingResponseStatus;
+    }
+    return undefined;
+  },
+})
+@ObjectType()
+abstract class BaseResponseStatus {
+  @Field(() => ResponseStatusCode)
+  code: ResponseStatusCode;
+}
+
+@ObjectType({ implements: BaseResponseStatus })
+export class PendingResponseStatus extends BaseResponseStatus {
+  code: ResponseStatusCode = ResponseStatusCode.Pending;
+}
+
+@ObjectType({ implements: BaseResponseStatus })
+export class SuccessResponseStatus extends BaseResponseStatus {
+  code: ResponseStatusCode = ResponseStatusCode.Success;
+}
+
+export enum FailedResponseStatusReason {
+  GUARDRAILS_VALIDATION_FAILED = "GUARDRAILS_VALIDATION_FAILED",
+  MESSAGE_STREAM_INTERRUPTED = "MESSAGE_STREAM_INTERRUPTED",
+  UNKNOWN_ERROR = "UNKNOWN_ERROR",
+}
+
+registerEnumType(FailedResponseStatusReason, {
+  name: "FailedResponseStatusReason",
+});
+
+@ObjectType({ implements: BaseResponseStatus })
+export class FailedResponseStatus extends BaseResponseStatus {
+  code: ResponseStatusCode = ResponseStatusCode.Failed;
+
+  @Field(() => FailedResponseStatusReason)
+  reason: FailedResponseStatusReason;
+
+  @Field(() => GraphQLJSON, { nullable: true })
+  details?: Record<string, any> = null;
+}
+
+export const ResponseStatusUnion = createUnionType({
+  name: "ResponseStatus",
+  types: () => [PendingResponseStatus, SuccessResponseStatus, FailedResponseStatus] as const,
+});

package/src/index.ts

@@ -0,0 +1,4 @@
+import "reflect-metadata";
+export * from "./lib";
+export * from "./utils";
+export * from "./service-adapters";

package/src/lib/cloud/index.ts

@@ -0,0 +1,4 @@
+export interface CopilotCloudOptions {
+  baseUrl?: string;
+  publicApiKey?: string;
+}

package/src/lib/index.ts

@@ -0,0 +1,8 @@
+export * from "./runtime/copilot-runtime";
+export * from "../service-adapters/openai/openai-adapter";
+export * from "../service-adapters/langchain/langchain-adapter";
+export * from "../service-adapters/google/google-genai-adapter";
+export * from "../service-adapters/openai/openai-assistant-adapter";
+export * from "../service-adapters/unify/unify-adapter";
+export * from "../service-adapters/groq/groq-adapter";
+export * from "./integrations";

package/src/lib/integrations/index.ts

@@ -0,0 +1,6 @@
+export * from "./shared";
+export * from "./nextjs/app-router";
+export * from "./nextjs/pages-router";
+export * from "./node-http";
+export * from "./node-express";
+export * from "./nest";

package/src/lib/integrations/nest/index.ts

@@ -0,0 +1,17 @@
+import { CreateCopilotRuntimeServerOptions } from "../shared";
+import { copilotRuntimeNodeHttpEndpoint } from "../node-http";
+import telemetry, { getRuntimeInstanceTelemetryInfo } from "../../telemetry-client";
+
+export function copilotRuntimeNestEndpoint(options: CreateCopilotRuntimeServerOptions) {
+  telemetry.setGlobalProperties({
+    runtime: {
+      framework: "nest",
+    },
+  });
+
+  telemetry.capture(
+    "oss.runtime.instance_created",
+    getRuntimeInstanceTelemetryInfo(options.runtime),
+  );
+  return copilotRuntimeNodeHttpEndpoint(options);
+}

package/src/lib/integrations/nextjs/app-router.ts

@@ -0,0 +1,40 @@
+import { createYoga } from "graphql-yoga";
+import { CreateCopilotRuntimeServerOptions, getCommonConfig } from "../shared";
+import telemetry, { getRuntimeInstanceTelemetryInfo } from "../../telemetry-client";
+
+export function copilotRuntimeNextJSAppRouterEndpoint(options: CreateCopilotRuntimeServerOptions) {
+  const commonConfig = getCommonConfig(options);
+
+  telemetry.setGlobalProperties({
+    runtime: {
+      framework: "nextjs-app-router",
+    },
+  });
+
+  if (options.properties?._copilotkit) {
+    telemetry.setGlobalProperties({
+      _copilotkit: options.properties._copilotkit,
+    });
+  }
+
+  telemetry.capture(
+    "oss.runtime.instance_created",
+    getRuntimeInstanceTelemetryInfo(options.runtime),
+  );
+
+  const logger = commonConfig.logging;
+  logger.debug("Creating NextJS App Router endpoint");
+
+  const yoga = createYoga({
+    ...commonConfig,
+    graphqlEndpoint: options.endpoint,
+    fetchAPI: { Response: globalThis.Response },
+  });
+
+  return {
+    handleRequest: yoga,
+    GET: yoga as any,
+    POST: yoga as any,
+    OPTIONS: yoga as any,
+  };
+}

package/src/lib/integrations/nextjs/pages-router.ts

@@ -0,0 +1,49 @@
+import { YogaServerInstance, createYoga } from "graphql-yoga";
+import { CreateCopilotRuntimeServerOptions, GraphQLContext, getCommonConfig } from "../shared";
+import telemetry, { getRuntimeInstanceTelemetryInfo } from "../../telemetry-client";
+
+export const config = {
+  api: {
+    bodyParser: false,
+  },
+};
+
+export type CopilotRuntimeServerInstance<T> = YogaServerInstance<T, Partial<GraphQLContext>>;
+
+// This import is needed to fix the type error
+// Fix is currently in TypeScript 5.5 beta, waiting for stable version
+// https://github.com/microsoft/TypeScript/issues/42873#issuecomment-2066874644
+export type {} from "@whatwg-node/server";
+
+export function copilotRuntimeNextJSPagesRouterEndpoint(
+  options: CreateCopilotRuntimeServerOptions,
+): CopilotRuntimeServerInstance<GraphQLContext> {
+  const commonConfig = getCommonConfig(options);
+
+  telemetry.setGlobalProperties({
+    runtime: {
+      framework: "nextjs-pages-router",
+    },
+  });
+
+  if (options.properties?._copilotkit) {
+    telemetry.setGlobalProperties({
+      _copilotkit: options.properties._copilotkit,
+    });
+  }
+
+  telemetry.capture(
+    "oss.runtime.instance_created",
+    getRuntimeInstanceTelemetryInfo(options.runtime),
+  );
+
+  const logger = commonConfig.logging;
+  logger.debug("Creating NextJS Pages Router endpoint");
+
+  const yoga = createYoga({
+    ...commonConfig,
+    graphqlEndpoint: options.endpoint,
+  });
+
+  return yoga;
+}

package/src/lib/integrations/node-express/index.ts

@@ -0,0 +1,17 @@
+import { CreateCopilotRuntimeServerOptions } from "../shared";
+import { copilotRuntimeNodeHttpEndpoint } from "../node-http";
+import telemetry, { getRuntimeInstanceTelemetryInfo } from "../../telemetry-client";
+
+export function copilotRuntimeNodeExpressEndpoint(options: CreateCopilotRuntimeServerOptions) {
+  telemetry.setGlobalProperties({
+    runtime: {
+      framework: "node-express",
+    },
+  });
+
+  telemetry.capture(
+    "oss.runtime.instance_created",
+    getRuntimeInstanceTelemetryInfo(options.runtime),
+  );
+  return copilotRuntimeNodeHttpEndpoint(options);
+}

package/src/lib/integrations/node-http/index.ts

@@ -0,0 +1,34 @@
+import { createYoga } from "graphql-yoga";
+import { CreateCopilotRuntimeServerOptions, getCommonConfig } from "../shared";
+import telemetry, { getRuntimeInstanceTelemetryInfo } from "../../telemetry-client";
+
+export function copilotRuntimeNodeHttpEndpoint(options: CreateCopilotRuntimeServerOptions) {
+  const commonConfig = getCommonConfig(options);
+
+  telemetry.setGlobalProperties({
+    runtime: {
+      framework: "node-http",
+    },
+  });
+
+  if (options.properties?._copilotkit) {
+    telemetry.setGlobalProperties({
+      _copilotkit: options.properties._copilotkit,
+    });
+  }
+
+  telemetry.capture(
+    "oss.runtime.instance_created",
+    getRuntimeInstanceTelemetryInfo(options.runtime),
+  );
+
+  const logger = commonConfig.logging;
+  logger.debug("Creating Node HTTP endpoint");
+
+  const yoga = createYoga({
+    ...commonConfig,
+    graphqlEndpoint: options.endpoint,
+  });
+
+  return yoga;
+}