@copilotkit/runtime 0.0.0-test-custom-tag-prerelease-1-20250108200215

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;
+}

package/src/lib/integrations/shared.ts

@@ -0,0 +1,109 @@
+import { YogaInitialContext } from "graphql-yoga";
+import { buildSchemaSync } from "type-graphql";
+import { CopilotResolver } from "../../graphql/resolvers/copilot.resolver";
+import { useDeferStream } from "@graphql-yoga/plugin-defer-stream";
+import { CopilotRuntime } from "../runtime/copilot-runtime";
+import { CopilotServiceAdapter } from "../../service-adapters";
+import { CopilotCloudOptions } from "../cloud";
+import { LogLevel, createLogger } from "../../lib/logger";
+import { createYoga } from "graphql-yoga";
+import telemetry from "../telemetry-client";
+
+const logger = createLogger();
+
+type AnyPrimitive = string | boolean | number | null;
+export type CopilotRequestContextProperties = Record<
+  string,
+  AnyPrimitive | Record<string, AnyPrimitive>
+>;
+
+export type GraphQLContext = YogaInitialContext & {
+  _copilotkit: CreateCopilotRuntimeServerOptions;
+  properties: CopilotRequestContextProperties;
+  logger: typeof logger;
+};
+
+export interface CreateCopilotRuntimeServerOptions {
+  runtime: CopilotRuntime<any>;
+  serviceAdapter: CopilotServiceAdapter;
+  endpoint: string;
+  baseUrl?: string;
+  cloud?: CopilotCloudOptions;
+  properties?: CopilotRequestContextProperties;
+  logLevel?: LogLevel;
+}
+
+export async function createContext(
+  initialContext: YogaInitialContext,
+  copilotKitContext: CreateCopilotRuntimeServerOptions,
+  contextLogger: typeof logger,
+  properties: CopilotRequestContextProperties = {},
+): Promise<Partial<GraphQLContext>> {
+  logger.debug({ copilotKitContext }, "Creating GraphQL context");
+  const ctx: GraphQLContext = {
+    ...initialContext,
+    _copilotkit: {
+      ...copilotKitContext,
+    },
+    properties: { ...properties },
+    logger: contextLogger,
+  };
+  return ctx;
+}
+
+export function buildSchema(
+  options: {
+    emitSchemaFile?: string;
+  } = {},
+) {
+  logger.debug("Building GraphQL schema...");
+  const schema = buildSchemaSync({
+    resolvers: [CopilotResolver],
+    emitSchemaFile: options.emitSchemaFile,
+  });
+  logger.debug("GraphQL schema built successfully");
+  return schema;
+}
+
+export type CommonConfig = {
+  logging: typeof logger;
+  schema: ReturnType<typeof buildSchema>;
+  plugins: Parameters<typeof createYoga>[0]["plugins"];
+  context: (ctx: YogaInitialContext) => Promise<Partial<GraphQLContext>>;
+};
+
+export function getCommonConfig(options: CreateCopilotRuntimeServerOptions): CommonConfig {
+  const logLevel = (process.env.LOG_LEVEL as LogLevel) || (options.logLevel as LogLevel) || "error";
+  const logger = createLogger({ level: logLevel, component: "getCommonConfig" });
+
+  const contextLogger = createLogger({ level: logLevel });
+
+  if (options.cloud) {
+    telemetry.setCloudConfiguration({
+      publicApiKey: options.cloud.publicApiKey,
+      baseUrl: options.cloud.baseUrl,
+    });
+  }
+
+  if (options.properties?._copilotkit) {
+    telemetry.setGlobalProperties({
+      _copilotkit: {
+        ...(options.properties._copilotkit as Record<string, any>),
+      },
+    });
+  }
+
+  telemetry.setGlobalProperties({
+    runtime: {
+      serviceAdapter: options.serviceAdapter.constructor.name,
+    },
+  });
+
+  return {
+    logging: createLogger({ component: "Yoga GraphQL", level: logLevel }),
+    schema: buildSchema(),
+    plugins: [useDeferStream()],
+    context: (ctx: YogaInitialContext): Promise<Partial<GraphQLContext>> =>
+      createContext(ctx, options, contextLogger, options.properties),
+  };
+}

package/src/lib/logger.ts

@@ -0,0 +1,28 @@
+import createPinoLogger from "pino";
+import pretty from "pino-pretty";
+
+export type LogLevel = "debug" | "info" | "warn" | "error";
+
+export type CopilotRuntimeLogger = ReturnType<typeof createLogger>;
+
+export function createLogger(options?: { level?: LogLevel; component?: string }) {
+  const { level, component } = options || {};
+  const stream = pretty({ colorize: true });
+
+  const logger = createPinoLogger(
+    {
+      level: process.env.LOG_LEVEL || level || "error",
+      redact: {
+        paths: ["pid", "hostname"],
+        remove: true,
+      },
+    },
+    stream,
+  );
+
+  if (component) {
+    return logger.child({ component });
+  } else {
+    return logger;
+  }
+}