@copilotkit/runtime 1.50.0-beta.8 → 1.50.0

package/dist/shared-da5708fe.d.ts

@@ -0,0 +1,449 @@
+import * as graphql from 'graphql';
+import * as pino from 'pino';
+import { YogaInitialContext, createYoga } from 'graphql-yoga';
+import { Parameter, Action, CopilotErrorHandler, PartialBy, MaybePromise, NonEmptyRecord } from '@copilotkit/shared';
+import { b as CopilotServiceAdapter, A as ActionInput, d as AgentSessionInput, e as AgentStateInput, F as ForwardedParametersInput, E as ExtensionsInput, R as RemoteChainParameters } from './langserve-9fc76ce5.js';
+import { CopilotRuntimeOptions, CopilotRuntime as CopilotRuntime$1 } from '@copilotkitnext/runtime';
+import { a as MessageInput, M as Message } from './index-adbd78f1.js';
+import { CopilotCloudOptions } from './lib/cloud/index.js';
+import { AbstractAgent } from '@ag-ui/client';
+
+declare enum MetaEventName {
+    LangGraphInterruptEvent = "LangGraphInterruptEvent",
+    CopilotKitLangGraphInterruptEvent = "CopilotKitLangGraphInterruptEvent"
+}
+
+declare class MetaEventInput {
+    name: MetaEventName;
+    value?: string;
+    response?: string;
+    messages?: MessageInput[];
+}
+
+interface BaseEndpointDefinition<TActionType extends EndpointType> {
+    type?: TActionType;
+}
+interface CopilotKitEndpoint extends BaseEndpointDefinition<EndpointType.CopilotKit> {
+    url: string;
+    onBeforeRequest?: ({ ctx }: {
+        ctx: GraphQLContext;
+    }) => {
+        headers?: Record<string, string> | undefined;
+    };
+}
+interface LangGraphPlatformAgent {
+    name: string;
+    description: string;
+    assistantId?: string;
+}
+interface LangGraphPlatformEndpoint extends BaseEndpointDefinition<EndpointType.LangGraphPlatform> {
+    deploymentUrl: string;
+    langsmithApiKey?: string | null;
+    agents: LangGraphPlatformAgent[];
+}
+type EndpointDefinition = CopilotKitEndpoint | LangGraphPlatformEndpoint;
+declare enum EndpointType {
+    CopilotKit = "copilotKit",
+    LangGraphPlatform = "langgraph-platform"
+}
+
+interface LLMRequestData {
+    threadId?: string;
+    runId?: string;
+    model?: string;
+    messages: any[];
+    actions?: any[];
+    forwardedParameters?: any;
+    timestamp: number;
+    provider?: string;
+    [key: string]: any;
+}
+interface LLMResponseData {
+    threadId: string;
+    runId?: string;
+    model?: string;
+    output: any;
+    latency: number;
+    timestamp: number;
+    provider?: string;
+    isProgressiveChunk?: boolean;
+    isFinalResponse?: boolean;
+    [key: string]: any;
+}
+interface LLMErrorData {
+    threadId?: string;
+    runId?: string;
+    model?: string;
+    error: Error | string;
+    timestamp: number;
+    provider?: string;
+    [key: string]: any;
+}
+interface CopilotObservabilityHooks {
+    handleRequest: (data: LLMRequestData) => void | Promise<void>;
+    handleResponse: (data: LLMResponseData) => void | Promise<void>;
+    handleError: (data: LLMErrorData) => void | Promise<void>;
+}
+/**
+ * Configuration for CopilotKit logging functionality.
+ *
+ * @remarks
+ * Custom logging handlers require a valid CopilotKit public API key.
+ * Sign up at https://docs.copilotkit.ai/quickstart#get-a-copilot-cloud-public-api-key to get your key.
+ */
+interface CopilotObservabilityConfig {
+    /**
+     * Enable or disable logging functionality.
+     *
+     * @default false
+     */
+    enabled: boolean;
+    /**
+     * Controls whether logs are streamed progressively or buffered.
+     * - When true: Each token and update is logged as it's generated (real-time)
+     * - When false: Complete responses are logged after completion (batched)
+     *
+     * @default true
+     */
+    progressive: boolean;
+    /**
+     * Custom observability hooks for request, response, and error events.
+     *
+     * @remarks
+     * Using custom observability hooks requires a valid CopilotKit public API key.
+     */
+    hooks: CopilotObservabilityHooks;
+}
+
+/**
+ * Represents a tool provided by an MCP server.
+ */
+interface MCPTool {
+    description?: string;
+    /** Schema defining parameters, mirroring the MCP structure. */
+    schema?: {
+        parameters?: {
+            properties?: Record<string, any>;
+            required?: string[];
+            jsonSchema?: Record<string, any>;
+        };
+    };
+    /** The function to call to execute the tool on the MCP server. */
+    execute(params: any): Promise<any>;
+}
+/**
+ * Defines the contract for *any* MCP client implementation the user might provide.
+ */
+interface MCPClient {
+    /** A method that returns a map of tool names to MCPTool objects available from the connected MCP server. */
+    tools(): Promise<Record<string, MCPTool>>;
+    /** An optional method for cleanup if the underlying client requires explicit disconnection. */
+    close?(): Promise<void>;
+}
+/**
+ * Configuration for connecting to an MCP endpoint.
+ */
+interface MCPEndpointConfig {
+    endpoint: string;
+    apiKey?: string;
+}
+/**
+ * Extracts CopilotKit-compatible parameters from an MCP tool schema.
+ * @param toolOrSchema The schema object from an MCPTool or the full MCPTool object.
+ * @returns An array of Parameter objects.
+ */
+declare function extractParametersFromSchema(toolOrSchema?: MCPTool | MCPTool["schema"]): Parameter[];
+/**
+ * Converts a map of MCPTools into an array of CopilotKit Actions.
+ * @param mcpTools A record mapping tool names to MCPTool objects.
+ * @param mcpEndpoint The endpoint URL from which these tools were fetched.
+ * @returns An array of Action<any> objects.
+ */
+declare function convertMCPToolsToActions(mcpTools: Record<string, MCPTool>, mcpEndpoint: string): Action<any>[];
+/**
+ * Generate better instructions for using MCP tools
+ * This is used to enhance the system prompt with tool documentation
+ */
+declare function generateMcpToolInstructions(toolsMap: Record<string, MCPTool>): string;
+
+declare class CopilotContextInput {
+    description: string;
+    value: string;
+}
+
+/**
+ * <Callout type="info">
+ *   This is the reference for the `CopilotRuntime` class. For more information and example code snippets, please see [Concept: Copilot Runtime](/concepts/copilot-runtime).
+ * </Callout>
+ *
+ * ## Usage
+ *
+ * ```tsx
+ * import { CopilotRuntime } from "@copilotkit/runtime";
+ *
+ * const copilotKit = new CopilotRuntime();
+ * ```
+ */
+
+type CreateMCPClientFunction = (config: MCPEndpointConfig) => Promise<MCPClient>;
+
+interface CopilotRuntimeRequest {
+    serviceAdapter: CopilotServiceAdapter;
+    messages: MessageInput[];
+    actions: ActionInput[];
+    agentSession?: AgentSessionInput;
+    agentStates?: AgentStateInput[];
+    outputMessagesPromise: Promise<Message[]>;
+    threadId?: string;
+    runId?: string;
+    publicApiKey?: string;
+    graphqlContext: GraphQLContext;
+    forwardedParameters?: ForwardedParametersInput;
+    url?: string;
+    extensions?: ExtensionsInput;
+    metaEvents?: MetaEventInput[];
+    context?: CopilotContextInput[];
+}
+type ActionsConfiguration<T extends Parameter[] | [] = []> = Action<T>[] | ((ctx: {
+    properties: any;
+    url?: string;
+}) => Action<T>[]);
+interface OnBeforeRequestOptions {
+    threadId?: string;
+    runId?: string;
+    inputMessages: Message[];
+    properties: any;
+    url?: string;
+}
+type OnBeforeRequestHandler = (options: OnBeforeRequestOptions) => void | Promise<void>;
+interface OnAfterRequestOptions {
+    threadId: string;
+    runId?: string;
+    inputMessages: Message[];
+    outputMessages: Message[];
+    properties: any;
+    url?: string;
+}
+type OnAfterRequestHandler = (options: OnAfterRequestOptions) => void | Promise<void>;
+interface OnStopGenerationOptions {
+    threadId: string;
+    runId?: string;
+    url?: string;
+    agentName?: string;
+    lastMessage: MessageInput;
+}
+type OnStopGenerationHandler = (options: OnStopGenerationOptions) => void | Promise<void>;
+interface Middleware {
+    /**
+     * A function that is called before the request is processed.
+     */
+    /**
+     * @deprecated This middleware hook is deprecated and will be removed in a future version.
+     * Use updated middleware integration methods in CopilotRuntimeVNext instead.
+     */
+    onBeforeRequest?: OnBeforeRequestHandler;
+    /**
+     * A function that is called after the request is processed.
+     */
+    /**
+     * @deprecated This middleware hook is deprecated and will be removed in a future version.
+     * Use updated middleware integration methods in CopilotRuntimeVNext instead.
+     */
+    onAfterRequest?: OnAfterRequestHandler;
+}
+interface CopilotRuntimeConstructorParams_BASE<T extends Parameter[] | [] = []> {
+    /**
+     * Middleware to be used by the runtime.
+     *
+     * ```ts
+     * onBeforeRequest: (options: {
+     *   threadId?: string;
+     *   runId?: string;
+     *   inputMessages: Message[];
+     *   properties: any;
+     * }) => void | Promise<void>;
+     * ```
+     *
+     * ```ts
+     * onAfterRequest: (options: {
+     *   threadId?: string;
+     *   runId?: string;
+     *   inputMessages: Message[];
+     *   outputMessages: Message[];
+     *   properties: any;
+     * }) => void | Promise<void>;
+     * ```
+     */
+    /**
+     * @deprecated This middleware hook is deprecated and will be removed in a future version.
+     * Use updated middleware integration methods in CopilotRuntimeVNext instead.
+     */
+    middleware?: Middleware;
+    actions?: ActionsConfiguration<T>;
+    remoteActions?: CopilotKitEndpoint[];
+    remoteEndpoints?: EndpointDefinition[];
+    langserve?: RemoteChainParameters[];
+    agents?: Record<string, AbstractAgent>;
+    delegateAgentProcessingToServiceAdapter?: boolean;
+    /**
+     * Configuration for LLM request/response logging.
+     * Requires publicApiKey from CopilotKit component to be set:
+     *
+     * ```tsx
+     * <CopilotKit publicApiKey="ck_pub_..." />
+     * ```
+     *
+     * Example logging config:
+     * ```ts
+     * logging: {
+     *   enabled: true, // Enable or disable logging
+     *   progressive: true, // Set to false for buffered logging
+     *   logger: {
+     *     logRequest: (data) => langfuse.trace({ name: "LLM Request", input: data }),
+     *     logResponse: (data) => langfuse.trace({ name: "LLM Response", output: data }),
+     *     logError: (errorData) => langfuse.trace({ name: "LLM Error", metadata: errorData }),
+     *   },
+     * }
+     * ```
+     */
+    observability_c?: CopilotObservabilityConfig;
+    /**
+     * Configuration for connecting to Model Context Protocol (MCP) servers.
+     * Allows fetching and using tools defined on external MCP-compliant servers.
+     * Requires providing the `createMCPClient` function during instantiation.
+     * @experimental
+     */
+    mcpServers?: MCPEndpointConfig[];
+    /**
+     * A function that creates an MCP client instance for a given endpoint configuration.
+     * This function is responsible for using the appropriate MCP client library
+     * (e.g., `@copilotkit/runtime`, `ai`) to establish a connection.
+     * Required if `mcpServers` is provided.
+     *
+     * ```typescript
+     * import { experimental_createMCPClient } from "ai"; // Import from vercel ai library
+     * // ...
+     * const runtime = new CopilotRuntime({
+     *   mcpServers: [{ endpoint: "..." }],
+     *   async createMCPClient(config) {
+     *     return await experimental_createMCPClient({
+     *       transport: {
+     *         type: "sse",
+     *         url: config.endpoint,
+     *         headers: config.apiKey
+     *           ? { Authorization: `Bearer ${config.apiKey}` }
+     *           : undefined,
+     *       },
+     *     });
+     *   }
+     * });
+     * ```
+     */
+    createMCPClient?: CreateMCPClientFunction;
+    /**
+     * Optional error handler for comprehensive debugging and observability.
+     *
+     * **Requires publicApiKey**: Error handling only works when requests include a valid publicApiKey.
+     * This is a premium Copilot Cloud feature.
+     *
+     * @param errorEvent - Structured error event with rich debugging context
+     *
+     * @example
+     * ```typescript
+     * const runtime = new CopilotRuntime({
+     *   onError: (errorEvent) => {
+     *     debugDashboard.capture(errorEvent);
+     *   }
+     * });
+     * ```
+     */
+    onError?: CopilotErrorHandler;
+    onStopGeneration?: OnStopGenerationHandler;
+}
+interface CopilotRuntimeConstructorParams<T extends Parameter[] | [] = []> extends Omit<CopilotRuntimeConstructorParams_BASE<T>, "agents">, Omit<CopilotRuntimeOptions, "agents" | "transcriptionService"> {
+    /**
+     * TODO: un-omit `transcriptionService` above once it's supported
+     *
+     * This satisfies...
+     *  – the optional constraint in `CopilotRuntimeConstructorParams_BASE`
+     *  – the `MaybePromise<NonEmptyRecord<T>>` constraint in `CopilotRuntimeOptionsVNext`
+     *  – the `Record<string, AbstractAgent>` constraint in `both
+     */
+    agents?: MaybePromise<NonEmptyRecord<Record<string, AbstractAgent>>>;
+}
+/**
+ * Central runtime object passed to all request handlers.
+ */
+declare class CopilotRuntime {
+    params?: CopilotRuntimeConstructorParams;
+    private observability?;
+    private mcpToolsCache;
+    private runtimeArgs;
+    private _instance;
+    constructor(params?: CopilotRuntimeConstructorParams & PartialBy<CopilotRuntimeOptions, "agents">);
+    get instance(): CopilotRuntime$1;
+    private assignEndpointsToAgents;
+    handleServiceAdapter(serviceAdapter: CopilotServiceAdapter): void;
+    private getToolsFromActions;
+    private assignToolsToAgents;
+    private createOnBeforeRequestHandler;
+    private createOnAfterRequestHandler;
+    /**
+     * Log LLM request if observability is enabled
+     */
+    private logObservabilityBeforeRequest;
+    /**
+     * Log final LLM response after request completes
+     */
+    private logObservabilityAfterRequest;
+    private getToolsFromMCP;
+}
+declare function copilotKitEndpoint(config: Omit<CopilotKitEndpoint, "type">): CopilotKitEndpoint;
+declare function langGraphPlatformEndpoint(config: Omit<LangGraphPlatformEndpoint, "type">): LangGraphPlatformEndpoint;
+declare function resolveEndpointType(endpoint: EndpointDefinition): EndpointType;
+
+type LogLevel = "debug" | "info" | "warn" | "error";
+type CopilotRuntimeLogger = ReturnType<typeof createLogger>;
+declare function createLogger(options?: {
+    level?: LogLevel;
+    component?: string;
+}): pino.Logger<never>;
+
+declare const logger: pino.Logger<never>;
+declare const addCustomHeaderPlugin: {
+    onResponse({ response }: {
+        response: any;
+    }): void;
+};
+type AnyPrimitive = string | boolean | number | null;
+type CopilotRequestContextProperties = Record<string, AnyPrimitive | Record<string, AnyPrimitive>>;
+type GraphQLContext = YogaInitialContext & {
+    _copilotkit: CreateCopilotRuntimeServerOptions;
+    properties: CopilotRequestContextProperties;
+    logger: typeof logger;
+};
+interface CreateCopilotRuntimeServerOptions {
+    runtime: CopilotRuntime;
+    serviceAdapter: CopilotServiceAdapter;
+    endpoint: string;
+    baseUrl?: string;
+    cloud?: CopilotCloudOptions;
+    properties?: CopilotRequestContextProperties;
+    logLevel?: LogLevel;
+}
+declare function createContext(initialContext: YogaInitialContext, copilotKitContext: CreateCopilotRuntimeServerOptions, contextLogger: typeof logger, properties?: CopilotRequestContextProperties): Promise<Partial<GraphQLContext>>;
+declare function buildSchema(options?: {
+    emitSchemaFile?: string;
+}): graphql.GraphQLSchema;
+type CommonConfig = {
+    logging: typeof logger;
+    schema: ReturnType<typeof buildSchema>;
+    plugins: Parameters<typeof createYoga>[0]["plugins"];
+    context: (ctx: YogaInitialContext) => Promise<Partial<GraphQLContext>>;
+    maskedErrors: {
+        maskError: (error: any, message: string, isDev?: boolean) => any;
+    };
+};
+declare function getCommonConfig(options: CreateCopilotRuntimeServerOptions): CommonConfig;
+
+export { CopilotRequestContextProperties as C, GraphQLContext as G, LogLevel as L, MCPTool as M, addCustomHeaderPlugin as a, CreateCopilotRuntimeServerOptions as b, createContext as c, buildSchema as d, CommonConfig as e, CopilotRuntimeLogger as f, getCommonConfig as g, createLogger as h, CopilotRuntimeRequest as i, CopilotRuntimeConstructorParams_BASE as j, CopilotRuntime as k, copilotKitEndpoint as l, langGraphPlatformEndpoint as m, MCPClient as n, MCPEndpointConfig as o, extractParametersFromSchema as p, convertMCPToolsToActions as q, resolveEndpointType as r, generateMcpToolInstructions as s };

package/dist/utils/index.d.ts

@@ -0,0 +1,65 @@
+declare enum ResponseStatusCode {
+    Pending = "pending",
+    Success = "success",
+    Failed = "failed"
+}
+declare abstract class BaseResponseStatus {
+    code: ResponseStatusCode;
+}
+declare enum FailedResponseStatusReason {
+    GUARDRAILS_VALIDATION_FAILED = "GUARDRAILS_VALIDATION_FAILED",
+    MESSAGE_STREAM_INTERRUPTED = "MESSAGE_STREAM_INTERRUPTED",
+    UNKNOWN_ERROR = "UNKNOWN_ERROR"
+}
+declare class FailedResponseStatus extends BaseResponseStatus {
+    code: ResponseStatusCode;
+    reason: FailedResponseStatusReason;
+    details?: Record<string, any>;
+}
+
+declare class GuardrailsValidationFailureResponse extends FailedResponseStatus {
+    reason: FailedResponseStatusReason;
+    details: {
+        guardrailsReason: string;
+    };
+    constructor({ guardrailsReason }: {
+        guardrailsReason: any;
+    });
+}
+declare class MessageStreamInterruptedResponse extends FailedResponseStatus {
+    reason: FailedResponseStatusReason;
+    details: {
+        messageId: string;
+        description: string;
+    };
+    constructor({ messageId }: {
+        messageId: string;
+    });
+}
+declare class UnknownErrorResponse extends FailedResponseStatus {
+    reason: FailedResponseStatusReason;
+    details: {
+        description?: string;
+        originalError?: {
+            code?: string;
+            statusCode?: number;
+            severity?: string;
+            visibility?: string;
+            originalErrorType?: string;
+            extensions?: any;
+        };
+    };
+    constructor({ description, originalError, }: {
+        description?: string;
+        originalError?: {
+            code?: string;
+            statusCode?: number;
+            severity?: string;
+            visibility?: string;
+            originalErrorType?: string;
+            extensions?: any;
+        };
+    });
+}
+
+export { GuardrailsValidationFailureResponse, MessageStreamInterruptedResponse, UnknownErrorResponse };

package/dist/utils/index.js

@@ -0,0 +1,175 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/utils/index.ts
+var utils_exports = {};
+__export(utils_exports, {
+  GuardrailsValidationFailureResponse: () => GuardrailsValidationFailureResponse,
+  MessageStreamInterruptedResponse: () => MessageStreamInterruptedResponse,
+  UnknownErrorResponse: () => UnknownErrorResponse
+});
+module.exports = __toCommonJS(utils_exports);
+
+// src/graphql/types/response-status.type.ts
+var import_graphql_scalars = require("graphql-scalars");
+var import_type_graphql = require("type-graphql");
+function _ts_decorate(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+    r = Reflect.decorate(decorators, target, key, desc);
+  else
+    for (var i = decorators.length - 1; i >= 0; i--)
+      if (d = decorators[i])
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate, "_ts_decorate");
+function _ts_metadata(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
+    return Reflect.metadata(k, v);
+}
+__name(_ts_metadata, "_ts_metadata");
+var ResponseStatusCode;
+(function(ResponseStatusCode2) {
+  ResponseStatusCode2["Pending"] = "pending";
+  ResponseStatusCode2["Success"] = "success";
+  ResponseStatusCode2["Failed"] = "failed";
+})(ResponseStatusCode || (ResponseStatusCode = {}));
+(0, import_type_graphql.registerEnumType)(ResponseStatusCode, {
+  name: "ResponseStatusCode"
+});
+var BaseResponseStatus = /* @__PURE__ */ __name(class BaseResponseStatus2 {
+  code;
+}, "BaseResponseStatus");
+_ts_decorate([
+  (0, import_type_graphql.Field)(() => ResponseStatusCode),
+  _ts_metadata("design:type", String)
+], BaseResponseStatus.prototype, "code", void 0);
+BaseResponseStatus = _ts_decorate([
+  (0, import_type_graphql.InterfaceType)({
+    resolveType(value) {
+      if (value.code === "success") {
+        return SuccessResponseStatus;
+      } else if (value.code === "failed") {
+        return FailedResponseStatus;
+      } else if (value.code === "pending") {
+        return PendingResponseStatus;
+      }
+      return void 0;
+    }
+  }),
+  (0, import_type_graphql.ObjectType)()
+], BaseResponseStatus);
+var PendingResponseStatus = class extends BaseResponseStatus {
+  code = "pending";
+};
+__name(PendingResponseStatus, "PendingResponseStatus");
+PendingResponseStatus = _ts_decorate([
+  (0, import_type_graphql.ObjectType)({
+    implements: BaseResponseStatus
+  })
+], PendingResponseStatus);
+var SuccessResponseStatus = class extends BaseResponseStatus {
+  code = "success";
+};
+__name(SuccessResponseStatus, "SuccessResponseStatus");
+SuccessResponseStatus = _ts_decorate([
+  (0, import_type_graphql.ObjectType)({
+    implements: BaseResponseStatus
+  })
+], SuccessResponseStatus);
+var FailedResponseStatusReason;
+(function(FailedResponseStatusReason2) {
+  FailedResponseStatusReason2["GUARDRAILS_VALIDATION_FAILED"] = "GUARDRAILS_VALIDATION_FAILED";
+  FailedResponseStatusReason2["MESSAGE_STREAM_INTERRUPTED"] = "MESSAGE_STREAM_INTERRUPTED";
+  FailedResponseStatusReason2["UNKNOWN_ERROR"] = "UNKNOWN_ERROR";
+})(FailedResponseStatusReason || (FailedResponseStatusReason = {}));
+(0, import_type_graphql.registerEnumType)(FailedResponseStatusReason, {
+  name: "FailedResponseStatusReason"
+});
+var FailedResponseStatus = class extends BaseResponseStatus {
+  code = "failed";
+  reason;
+  details = null;
+};
+__name(FailedResponseStatus, "FailedResponseStatus");
+_ts_decorate([
+  (0, import_type_graphql.Field)(() => FailedResponseStatusReason),
+  _ts_metadata("design:type", String)
+], FailedResponseStatus.prototype, "reason", void 0);
+_ts_decorate([
+  (0, import_type_graphql.Field)(() => import_graphql_scalars.GraphQLJSON, {
+    nullable: true
+  }),
+  _ts_metadata("design:type", typeof Record === "undefined" ? Object : Record)
+], FailedResponseStatus.prototype, "details", void 0);
+FailedResponseStatus = _ts_decorate([
+  (0, import_type_graphql.ObjectType)({
+    implements: BaseResponseStatus
+  })
+], FailedResponseStatus);
+var ResponseStatusUnion = (0, import_type_graphql.createUnionType)({
+  name: "ResponseStatus",
+  types: () => [
+    PendingResponseStatus,
+    SuccessResponseStatus,
+    FailedResponseStatus
+  ]
+});
+
+// src/utils/failed-response-status-reasons.ts
+var GuardrailsValidationFailureResponse = class extends FailedResponseStatus {
+  reason = FailedResponseStatusReason.GUARDRAILS_VALIDATION_FAILED;
+  constructor({ guardrailsReason }) {
+    super();
+    this.details = {
+      guardrailsReason
+    };
+  }
+};
+__name(GuardrailsValidationFailureResponse, "GuardrailsValidationFailureResponse");
+var MessageStreamInterruptedResponse = class extends FailedResponseStatus {
+  reason = FailedResponseStatusReason.MESSAGE_STREAM_INTERRUPTED;
+  constructor({ messageId }) {
+    super();
+    this.details = {
+      messageId,
+      description: "Check the message for mode details"
+    };
+  }
+};
+__name(MessageStreamInterruptedResponse, "MessageStreamInterruptedResponse");
+var UnknownErrorResponse = class extends FailedResponseStatus {
+  reason = FailedResponseStatusReason.UNKNOWN_ERROR;
+  constructor({ description, originalError }) {
+    super();
+    this.details = {
+      description,
+      originalError
+    };
+  }
+};
+__name(UnknownErrorResponse, "UnknownErrorResponse");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  GuardrailsValidationFailureResponse,
+  MessageStreamInterruptedResponse,
+  UnknownErrorResponse
+});
+//# sourceMappingURL=index.js.map