@copilotkit/runtime 0.0.0-0.0.0-max-changeset-10101010101010-20260109191632

package/src/graphql/resolvers/state.resolver.ts

@@ -0,0 +1,27 @@
+import { Arg, Resolver } from "type-graphql";
+import { Ctx } from "type-graphql";
+import { Query } from "type-graphql";
+import { LoadAgentStateResponse } from "../types/load-agent-state-response.type";
+import type { GraphQLContext } from "../../lib/integrations";
+import { LoadAgentStateInput } from "../inputs/load-agent-state.input";
+import { CopilotKitAgentDiscoveryError } from "@copilotkit/shared";
+import { CopilotRuntime } from "../../lib";
+
+@Resolver(() => LoadAgentStateResponse)
+export class StateResolver {
+  @Query(() => LoadAgentStateResponse)
+  async loadAgentState(@Ctx() ctx: GraphQLContext, @Arg("data") data: LoadAgentStateInput) {
+    const agents = [];
+    const hasAgent = agents.some((agent) => agent.name === data.agentName);
+    if (!hasAgent) {
+      throw new CopilotKitAgentDiscoveryError({
+        agentName: data.agentName,
+        availableAgents: agents.map((a) => ({ name: a.name, id: a.name })),
+      });
+    }
+
+    const state = {};
+
+    return state;
+  }
+}

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

@@ -0,0 +1,19 @@
+import { Field, ObjectType } from "type-graphql";
+
+@ObjectType()
+export class Agent {
+  @Field(() => String)
+  id: string;
+
+  @Field(() => String)
+  name: string;
+
+  @Field(() => String)
+  description?: string;
+}
+
+@ObjectType()
+export class AgentsResponse {
+  @Field(() => [Agent])
+  agents: Agent[];
+}

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

@@ -0,0 +1,10 @@
+import { Field, InputType } from "type-graphql";
+
+@InputType()
+export class BaseMessageInput {
+  @Field(() => String)
+  id: string;
+
+  @Field(() => Date)
+  createdAt: Date;
+}

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

@@ -0,0 +1,176 @@
+import { randomId } from "@copilotkit/shared";
+import {
+  ActionExecutionMessageInput,
+  ResultMessageInput,
+  TextMessageInput,
+  AgentStateMessageInput,
+  ImageMessageInput,
+} from "../../inputs/message.input";
+import { BaseMessageInput } from "../base";
+import { BaseMessageOutput } from "../copilot-response.type";
+import { MessageRole } from "../enums";
+import { MessageStatus, MessageStatusCode } from "../message-status.type";
+
+export type MessageType =
+  | "TextMessage"
+  | "ActionExecutionMessage"
+  | "ResultMessage"
+  | "AgentStateMessage"
+  | "ImageMessage";
+
+export class Message {
+  type: MessageType;
+  id: BaseMessageOutput["id"];
+  createdAt: BaseMessageOutput["createdAt"];
+  status: MessageStatus;
+
+  constructor(props: any) {
+    props.id ??= randomId();
+    props.status ??= { code: MessageStatusCode.Success };
+    props.createdAt ??= new Date();
+    Object.assign(this, props);
+  }
+
+  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";
+  }
+
+  isImageMessage(): this is ImageMessage {
+    return this.type === "ImageMessage";
+  }
+}
+
+// alias Role to MessageRole
+export const Role = MessageRole;
+
+// when constructing any message, the base fields are optional
+type MessageConstructorOptions = Partial<Message>;
+
+type TextMessageConstructorOptions = MessageConstructorOptions & TextMessageInput;
+
+export class TextMessage extends Message implements TextMessageConstructorOptions {
+  content: TextMessageInput["content"];
+  parentMessageId: TextMessageInput["parentMessageId"];
+  role: TextMessageInput["role"];
+  type = "TextMessage" as const;
+
+  constructor(props: TextMessageConstructorOptions) {
+    super(props);
+    this.type = "TextMessage";
+  }
+}
+
+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;
+}
+
+export class ImageMessage extends Message implements ImageMessageInput {
+  type: MessageType = "ImageMessage";
+  format: string;
+  bytes: string;
+  role: MessageRole;
+  parentMessageId?: string;
+}

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

@@ -0,0 +1,138 @@
+import { Field, InterfaceType, ObjectType } from "type-graphql";
+import { MessageRole } from "./enums";
+import { MessageStatusUnion } from "./message-status.type";
+import { ResponseStatusUnion } from "./response-status.type";
+import { ExtensionsResponse } from "./extensions-response.type";
+import { BaseMetaEvent } from "./meta-events.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;
+    } else if (value.hasOwnProperty("format") && value.hasOwnProperty("bytes")) {
+      return ImageMessageOutput;
+    }
+    return undefined;
+  },
+})
+export 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({ implements: BaseMessageOutput })
+export class ImageMessageOutput {
+  @Field(() => String)
+  format: string;
+
+  @Field(() => String)
+  bytes: string;
+
+  @Field(() => MessageRole)
+  role: MessageRole;
+
+  @Field(() => String, { nullable: true })
+  parentMessageId?: string;
+}
+
+@ObjectType()
+export class CopilotResponse {
+  @Field(() => String)
+  threadId!: string;
+
+  @Field(() => ResponseStatusUnion)
+  status: typeof ResponseStatusUnion;
+
+  @Field({ nullable: true })
+  runId?: string;
+
+  @Field(() => [BaseMessageOutput])
+  messages: (typeof BaseMessageOutput)[];
+
+  @Field(() => ExtensionsResponse, { nullable: true })
+  extensions?: ExtensionsResponse;
+
+  @Field(() => [BaseMetaEvent], { nullable: true })
+  metaEvents?: (typeof BaseMetaEvent)[];
+}

package/src/graphql/types/enums.ts

@@ -0,0 +1,38 @@
+import { registerEnumType } from "type-graphql";
+
+export enum MessageRole {
+  assistant = "assistant",
+  developer = "developer",
+  system = "system",
+  tool = "tool",
+  user = "user",
+}
+
+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/extensions-response.type.ts

@@ -0,0 +1,23 @@
+import { Field, ObjectType } from "type-graphql";
+
+/**
+ * The extensions response is used to receive additional information from the copilot runtime, specific to a
+ * service adapter or agent framework.
+ *
+ * Next time a request to the runtime is made, the extensions response will be included in the request as input.
+ */
+
+@ObjectType()
+export class ExtensionsResponse {
+  @Field(() => OpenAIApiAssistantAPIResponse, { nullable: true })
+  openaiAssistantAPI?: OpenAIApiAssistantAPIResponse;
+}
+
+@ObjectType()
+export class OpenAIApiAssistantAPIResponse {
+  @Field(() => String, { nullable: true })
+  runId?: string;
+
+  @Field(() => String, { nullable: true })
+  threadId?: string;
+}

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/load-agent-state-response.type.ts

@@ -0,0 +1,17 @@
+import { Field, ObjectType } from "type-graphql";
+import { BaseMessageOutput } from "./copilot-response.type";
+
+@ObjectType()
+export class LoadAgentStateResponse {
+  @Field(() => String)
+  threadId: string;
+
+  @Field(() => Boolean)
+  threadExists: boolean;
+
+  @Field(() => String)
+  state: string;
+
+  @Field(() => String)
+  messages: string;
+}

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

@@ -0,0 +1,42 @@
+import { Field, ObjectType, createUnionType, registerEnumType } from "type-graphql";
+
+export enum MessageStatusCode {
+  Pending = "pending",
+  Success = "success",
+  Failed = "failed",
+}
+
+registerEnumType(MessageStatusCode, {
+  name: "MessageStatusCode",
+});
+
+@ObjectType()
+export 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,
+});
+
+export type MessageStatus = typeof MessageStatusUnion;

package/src/graphql/types/meta-events.type.ts

@@ -0,0 +1,71 @@
+import { createUnionType, Field, InterfaceType, ObjectType, registerEnumType } from "type-graphql";
+import {
+  ActionExecutionMessageOutput,
+  AgentStateMessageOutput,
+  BaseMessageOutput,
+  ResultMessageOutput,
+  TextMessageOutput,
+} from "./copilot-response.type";
+
+export enum MetaEventName {
+  LangGraphInterruptEvent = "LangGraphInterruptEvent",
+  CopilotKitLangGraphInterruptEvent = "CopilotKitLangGraphInterruptEvent",
+}
+
+registerEnumType(MetaEventName, {
+  name: "MetaEventName",
+  description: "Meta event types",
+});
+
+@InterfaceType({
+  resolveType(value) {
+    if (value.name === MetaEventName.LangGraphInterruptEvent) {
+      return LangGraphInterruptEvent;
+    } else if (value.name === MetaEventName.CopilotKitLangGraphInterruptEvent) {
+      return CopilotKitLangGraphInterruptEvent;
+    }
+    return undefined;
+  },
+})
+@InterfaceType()
+export abstract class BaseMetaEvent {
+  @Field(() => String)
+  type: "MetaEvent" = "MetaEvent";
+
+  @Field(() => MetaEventName)
+  name: MetaEventName;
+}
+
+@ObjectType()
+export class CopilotKitLangGraphInterruptEventData {
+  @Field(() => String)
+  value: string;
+
+  @Field(() => [BaseMessageOutput])
+  messages: (typeof BaseMessageOutput)[];
+}
+
+@ObjectType({ implements: BaseMetaEvent })
+export class LangGraphInterruptEvent {
+  @Field(() => MetaEventName)
+  name: MetaEventName.LangGraphInterruptEvent = MetaEventName.LangGraphInterruptEvent;
+
+  @Field(() => String)
+  value: string;
+
+  @Field(() => String, { nullable: true })
+  response?: string;
+}
+
+@ObjectType({ implements: BaseMetaEvent })
+export class CopilotKitLangGraphInterruptEvent {
+  @Field(() => MetaEventName)
+  name: MetaEventName.CopilotKitLangGraphInterruptEvent =
+    MetaEventName.CopilotKitLangGraphInterruptEvent;
+
+  @Field(() => CopilotKitLangGraphInterruptEventData)
+  data: CopilotKitLangGraphInterruptEventData;
+
+  @Field(() => String, { nullable: true })
+  response?: string;
+}

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/langgraph.ts

@@ -0,0 +1 @@
+export * from "./lib/runtime/agent-integrations/langgraph";

package/src/lib/cloud/index.ts

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