@copilotkit/runtime 1.50.0-beta.9 → 1.50.0

package/dist/chunk-ZE4SMZZR.mjs

@@ -0,0 +1,3097 @@
+import {
+  BaseMessageInput
+} from "./chunk-2OZAGFV3.mjs";
+import {
+  GuardrailsValidationFailureResponse,
+  MessageStreamInterruptedResponse,
+  ResponseStatusUnion,
+  SuccessResponseStatus,
+  UnknownErrorResponse
+} from "./chunk-XWBDEXDA.mjs";
+import {
+  aguiToGQL
+} from "./chunk-62NE5S6M.mjs";
+import {
+  ActionExecutionMessage,
+  ActionInputAvailability,
+  AgentStateMessage,
+  CopilotRequestType,
+  FailedMessageStatus,
+  MessageRole,
+  MessageStatusUnion,
+  ResultMessage,
+  SuccessMessageStatus,
+  TextMessage
+} from "./chunk-OWIGJONH.mjs";
+import {
+  __commonJS,
+  __name,
+  __toESM
+} from "./chunk-FHD4JECV.mjs";
+
+// package.json
+var require_package = __commonJS({
+  "package.json"(exports, module) {
+    module.exports = {
+      name: "@copilotkit/runtime",
+      private: false,
+      homepage: "https://github.com/CopilotKit/CopilotKit",
+      repository: {
+        type: "git",
+        url: "https://github.com/CopilotKit/CopilotKit.git"
+      },
+      publishConfig: {
+        access: "public"
+      },
+      version: "1.10.6",
+      sideEffects: false,
+      main: "./dist/index.js",
+      module: "./dist/index.mjs",
+      exports: {
+        ".": {
+          import: "./dist/index.mjs",
+          require: "./dist/index.js",
+          types: "./dist/index.d.ts"
+        },
+        "./v2": {
+          import: "./dist/v2/index.mjs",
+          require: "./dist/v2/index.js",
+          types: "./dist/v2/index.d.ts"
+        }
+      },
+      types: "./dist/index.d.ts",
+      license: "MIT",
+      scripts: {
+        build: 'tsup --onSuccess "pnpm run generate-graphql-schema"',
+        dev: 'tsup --watch --onSuccess "pnpm run generate-graphql-schema"',
+        test: "jest --passWithNoTests",
+        "check-types": "tsc --noEmit",
+        clean: "rm -rf .turbo && rm -rf node_modules && rm -rf dist && rm -rf .next && rm -rf __snapshots__",
+        "generate-graphql-schema": "rm -rf __snapshots__ && ts-node ./scripts/generate-gql-schema.ts",
+        "link:global": "pnpm link --global",
+        "unlink:global": "pnpm unlink --global"
+      },
+      devDependencies: {
+        "@jest/globals": "^29.7.0",
+        "@swc/core": "1.5.28",
+        "@types/express": "^4.17.21",
+        "@types/jest": "^29.5.12",
+        "@types/node": "^18.11.17",
+        "@whatwg-node/server": "^0.9.34",
+        eslint: "^8.56.0",
+        "eslint-config-custom": "workspace:*",
+        jest: "^29.6.4",
+        nodemon: "^3.1.3",
+        "ts-jest": "^29.1.1",
+        "ts-node": "^10.9.2",
+        tsconfig: "workspace:*",
+        tsup: "^6.7.0",
+        typescript: "^5.2.3",
+        vitest: "^3.2.4",
+        "zod-to-json-schema": "^3.23.5"
+      },
+      dependencies: {
+        "@anthropic-ai/sdk": "^0.57.0",
+        "@copilotkit/shared": "workspace:*",
+        "@copilotkitnext/agent": "0.0.21",
+        "@copilotkitnext/runtime": "0.0.21",
+        "@graphql-yoga/plugin-defer-stream": "^3.3.1",
+        "@langchain/aws": "^0.1.9",
+        "@langchain/community": "^0.3.29",
+        "@langchain/core": "^0.3.38",
+        "@langchain/google-gauth": "^0.1.0",
+        "@langchain/langgraph-sdk": "^0.0.70",
+        "@langchain/openai": "^0.4.2",
+        "@scarf/scarf": "^1.3.0",
+        "class-transformer": "^0.5.1",
+        "class-validator": "^0.14.1",
+        express: "^4.19.2",
+        graphql: "^16.8.1",
+        "graphql-scalars": "^1.23.0",
+        "graphql-yoga": "^5.3.1",
+        "groq-sdk": "^0.5.0",
+        hono: "^4.10.3",
+        langchain: "^0.3.3",
+        openai: "^4.85.1",
+        "partial-json": "^0.1.7",
+        pino: "^9.2.0",
+        "pino-pretty": "^11.2.1",
+        "reflect-metadata": "^0.2.2",
+        rxjs: "7.8.1",
+        "type-graphql": "2.0.0-rc.1",
+        zod: "^3.23.3"
+      },
+      peerDependencies: {
+        "@ag-ui/client": ">=0.0.39",
+        "@ag-ui/core": ">=0.0.39",
+        "@ag-ui/encoder": ">=0.0.39",
+        "@ag-ui/langgraph": ">=0.0.18",
+        "@ag-ui/proto": ">=0.0.39"
+      },
+      keywords: [
+        "copilotkit",
+        "copilot",
+        "react",
+        "nextjs",
+        "nodejs",
+        "ai",
+        "assistant",
+        "javascript",
+        "automation",
+        "textarea"
+      ]
+    };
+  }
+});
+
+// src/lib/integrations/shared.ts
+import { buildSchemaSync } from "type-graphql";
+
+// src/graphql/resolvers/copilot.resolver.ts
+import { Arg, Ctx, Mutation, Query, Resolver } from "type-graphql";
+import { ReplaySubject as ReplaySubject2, Subject, filter, finalize, firstValueFrom, shareReplay, skipWhile, take, takeWhile, tap } from "rxjs";
+
+// src/graphql/inputs/generate-copilot-response.input.ts
+import { Field as Field15, InputType as InputType12 } from "type-graphql";
+
+// src/graphql/inputs/message.input.ts
+import { Field, InputType } from "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 MessageInput = class extends BaseMessageInput {
+  textMessage;
+  actionExecutionMessage;
+  resultMessage;
+  agentStateMessage;
+  imageMessage;
+};
+__name(MessageInput, "MessageInput");
+_ts_decorate([
+  Field(() => TextMessageInput, {
+    nullable: true
+  }),
+  _ts_metadata("design:type", typeof TextMessageInput === "undefined" ? Object : TextMessageInput)
+], MessageInput.prototype, "textMessage", void 0);
+_ts_decorate([
+  Field(() => ActionExecutionMessageInput, {
+    nullable: true
+  }),
+  _ts_metadata("design:type", typeof ActionExecutionMessageInput === "undefined" ? Object : ActionExecutionMessageInput)
+], MessageInput.prototype, "actionExecutionMessage", void 0);
+_ts_decorate([
+  Field(() => ResultMessageInput, {
+    nullable: true
+  }),
+  _ts_metadata("design:type", typeof ResultMessageInput === "undefined" ? Object : ResultMessageInput)
+], MessageInput.prototype, "resultMessage", void 0);
+_ts_decorate([
+  Field(() => AgentStateMessageInput, {
+    nullable: true
+  }),
+  _ts_metadata("design:type", typeof AgentStateMessageInput === "undefined" ? Object : AgentStateMessageInput)
+], MessageInput.prototype, "agentStateMessage", void 0);
+_ts_decorate([
+  Field(() => ImageMessageInput, {
+    nullable: true
+  }),
+  _ts_metadata("design:type", typeof ImageMessageInput === "undefined" ? Object : ImageMessageInput)
+], MessageInput.prototype, "imageMessage", void 0);
+MessageInput = _ts_decorate([
+  InputType()
+], MessageInput);
+var TextMessageInput = class {
+  content;
+  parentMessageId;
+  role;
+};
+__name(TextMessageInput, "TextMessageInput");
+_ts_decorate([
+  Field(() => String),
+  _ts_metadata("design:type", String)
+], TextMessageInput.prototype, "content", void 0);
+_ts_decorate([
+  Field(() => String, {
+    nullable: true
+  }),
+  _ts_metadata("design:type", String)
+], TextMessageInput.prototype, "parentMessageId", void 0);
+_ts_decorate([
+  Field(() => MessageRole),
+  _ts_metadata("design:type", typeof MessageRole === "undefined" ? Object : MessageRole)
+], TextMessageInput.prototype, "role", void 0);
+TextMessageInput = _ts_decorate([
+  InputType()
+], TextMessageInput);
+var ActionExecutionMessageInput = class {
+  name;
+  arguments;
+  parentMessageId;
+  scope;
+};
+__name(ActionExecutionMessageInput, "ActionExecutionMessageInput");
+_ts_decorate([
+  Field(() => String),
+  _ts_metadata("design:type", String)
+], ActionExecutionMessageInput.prototype, "name", void 0);
+_ts_decorate([
+  Field(() => String),
+  _ts_metadata("design:type", String)
+], ActionExecutionMessageInput.prototype, "arguments", void 0);
+_ts_decorate([
+  Field(() => String, {
+    nullable: true
+  }),
+  _ts_metadata("design:type", String)
+], ActionExecutionMessageInput.prototype, "parentMessageId", void 0);
+_ts_decorate([
+  Field(() => String, {
+    nullable: true,
+    deprecationReason: "This field will be removed in a future version"
+  }),
+  _ts_metadata("design:type", typeof String === "undefined" ? Object : String)
+], ActionExecutionMessageInput.prototype, "scope", void 0);
+ActionExecutionMessageInput = _ts_decorate([
+  InputType()
+], ActionExecutionMessageInput);
+var ResultMessageInput = class {
+  actionExecutionId;
+  actionName;
+  parentMessageId;
+  result;
+};
+__name(ResultMessageInput, "ResultMessageInput");
+_ts_decorate([
+  Field(() => String),
+  _ts_metadata("design:type", String)
+], ResultMessageInput.prototype, "actionExecutionId", void 0);
+_ts_decorate([
+  Field(() => String),
+  _ts_metadata("design:type", String)
+], ResultMessageInput.prototype, "actionName", void 0);
+_ts_decorate([
+  Field(() => String, {
+    nullable: true
+  }),
+  _ts_metadata("design:type", String)
+], ResultMessageInput.prototype, "parentMessageId", void 0);
+_ts_decorate([
+  Field(() => String),
+  _ts_metadata("design:type", String)
+], ResultMessageInput.prototype, "result", void 0);
+ResultMessageInput = _ts_decorate([
+  InputType()
+], ResultMessageInput);
+var AgentStateMessageInput = class {
+  threadId;
+  agentName;
+  role;
+  state;
+  running;
+  nodeName;
+  runId;
+  active;
+};
+__name(AgentStateMessageInput, "AgentStateMessageInput");
+_ts_decorate([
+  Field(() => String),
+  _ts_metadata("design:type", String)
+], AgentStateMessageInput.prototype, "threadId", void 0);
+_ts_decorate([
+  Field(() => String),
+  _ts_metadata("design:type", String)
+], AgentStateMessageInput.prototype, "agentName", void 0);
+_ts_decorate([
+  Field(() => MessageRole),
+  _ts_metadata("design:type", typeof MessageRole === "undefined" ? Object : MessageRole)
+], AgentStateMessageInput.prototype, "role", void 0);
+_ts_decorate([
+  Field(() => String),
+  _ts_metadata("design:type", String)
+], AgentStateMessageInput.prototype, "state", void 0);
+_ts_decorate([
+  Field(() => Boolean),
+  _ts_metadata("design:type", Boolean)
+], AgentStateMessageInput.prototype, "running", void 0);
+_ts_decorate([
+  Field(() => String),
+  _ts_metadata("design:type", String)
+], AgentStateMessageInput.prototype, "nodeName", void 0);
+_ts_decorate([
+  Field(() => String),
+  _ts_metadata("design:type", String)
+], AgentStateMessageInput.prototype, "runId", void 0);
+_ts_decorate([
+  Field(() => Boolean),
+  _ts_metadata("design:type", Boolean)
+], AgentStateMessageInput.prototype, "active", void 0);
+AgentStateMessageInput = _ts_decorate([
+  InputType()
+], AgentStateMessageInput);
+var ImageMessageInput = class {
+  format;
+  bytes;
+  parentMessageId;
+  role;
+};
+__name(ImageMessageInput, "ImageMessageInput");
+_ts_decorate([
+  Field(() => String),
+  _ts_metadata("design:type", String)
+], ImageMessageInput.prototype, "format", void 0);
+_ts_decorate([
+  Field(() => String),
+  _ts_metadata("design:type", String)
+], ImageMessageInput.prototype, "bytes", void 0);
+_ts_decorate([
+  Field(() => String, {
+    nullable: true
+  }),
+  _ts_metadata("design:type", String)
+], ImageMessageInput.prototype, "parentMessageId", void 0);
+_ts_decorate([
+  Field(() => MessageRole),
+  _ts_metadata("design:type", typeof MessageRole === "undefined" ? Object : MessageRole)
+], ImageMessageInput.prototype, "role", void 0);
+ImageMessageInput = _ts_decorate([
+  InputType()
+], ImageMessageInput);
+
+// src/graphql/inputs/frontend.input.ts
+import { Field as Field3, InputType as InputType3 } from "type-graphql";
+
+// src/graphql/inputs/action.input.ts
+import { Field as Field2, InputType as InputType2 } from "type-graphql";
+function _ts_decorate2(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_decorate2, "_ts_decorate");
+function _ts_metadata2(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
+    return Reflect.metadata(k, v);
+}
+__name(_ts_metadata2, "_ts_metadata");
+var ActionInput = class {
+  name;
+  description;
+  jsonSchema;
+  available;
+};
+__name(ActionInput, "ActionInput");
+_ts_decorate2([
+  Field2(() => String),
+  _ts_metadata2("design:type", String)
+], ActionInput.prototype, "name", void 0);
+_ts_decorate2([
+  Field2(() => String),
+  _ts_metadata2("design:type", String)
+], ActionInput.prototype, "description", void 0);
+_ts_decorate2([
+  Field2(() => String),
+  _ts_metadata2("design:type", String)
+], ActionInput.prototype, "jsonSchema", void 0);
+_ts_decorate2([
+  Field2(() => ActionInputAvailability, {
+    nullable: true
+  }),
+  _ts_metadata2("design:type", typeof ActionInputAvailability === "undefined" ? Object : ActionInputAvailability)
+], ActionInput.prototype, "available", void 0);
+ActionInput = _ts_decorate2([
+  InputType2()
+], ActionInput);
+
+// src/graphql/inputs/frontend.input.ts
+function _ts_decorate3(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_decorate3, "_ts_decorate");
+function _ts_metadata3(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
+    return Reflect.metadata(k, v);
+}
+__name(_ts_metadata3, "_ts_metadata");
+var FrontendInput = class {
+  toDeprecate_fullContext;
+  actions;
+  url;
+};
+__name(FrontendInput, "FrontendInput");
+_ts_decorate3([
+  Field3(() => String, {
+    nullable: true
+  }),
+  _ts_metadata3("design:type", String)
+], FrontendInput.prototype, "toDeprecate_fullContext", void 0);
+_ts_decorate3([
+  Field3(() => [
+    ActionInput
+  ]),
+  _ts_metadata3("design:type", Array)
+], FrontendInput.prototype, "actions", void 0);
+_ts_decorate3([
+  Field3(() => String, {
+    nullable: true
+  }),
+  _ts_metadata3("design:type", String)
+], FrontendInput.prototype, "url", void 0);
+FrontendInput = _ts_decorate3([
+  InputType3()
+], FrontendInput);
+
+// src/graphql/inputs/cloud.input.ts
+import { Field as Field5, InputType as InputType5 } from "type-graphql";
+
+// src/graphql/inputs/cloud-guardrails.input.ts
+import { Field as Field4, InputType as InputType4 } from "type-graphql";
+function _ts_decorate4(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_decorate4, "_ts_decorate");
+function _ts_metadata4(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
+    return Reflect.metadata(k, v);
+}
+__name(_ts_metadata4, "_ts_metadata");
+var GuardrailsRuleInput = class {
+  allowList = [];
+  denyList = [];
+};
+__name(GuardrailsRuleInput, "GuardrailsRuleInput");
+_ts_decorate4([
+  Field4(() => [
+    String
+  ], {
+    nullable: true
+  }),
+  _ts_metadata4("design:type", Array)
+], GuardrailsRuleInput.prototype, "allowList", void 0);
+_ts_decorate4([
+  Field4(() => [
+    String
+  ], {
+    nullable: true
+  }),
+  _ts_metadata4("design:type", Array)
+], GuardrailsRuleInput.prototype, "denyList", void 0);
+GuardrailsRuleInput = _ts_decorate4([
+  InputType4()
+], GuardrailsRuleInput);
+var GuardrailsInput = class {
+  inputValidationRules;
+};
+__name(GuardrailsInput, "GuardrailsInput");
+_ts_decorate4([
+  Field4(() => GuardrailsRuleInput, {
+    nullable: false
+  }),
+  _ts_metadata4("design:type", typeof GuardrailsRuleInput === "undefined" ? Object : GuardrailsRuleInput)
+], GuardrailsInput.prototype, "inputValidationRules", void 0);
+GuardrailsInput = _ts_decorate4([
+  InputType4()
+], GuardrailsInput);
+
+// src/graphql/inputs/cloud.input.ts
+function _ts_decorate5(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_decorate5, "_ts_decorate");
+function _ts_metadata5(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
+    return Reflect.metadata(k, v);
+}
+__name(_ts_metadata5, "_ts_metadata");
+var CloudInput = class {
+  guardrails;
+};
+__name(CloudInput, "CloudInput");
+_ts_decorate5([
+  Field5(() => GuardrailsInput, {
+    nullable: true
+  }),
+  _ts_metadata5("design:type", typeof GuardrailsInput === "undefined" ? Object : GuardrailsInput)
+], CloudInput.prototype, "guardrails", void 0);
+CloudInput = _ts_decorate5([
+  InputType5()
+], CloudInput);
+
+// src/graphql/inputs/forwarded-parameters.input.ts
+import { Field as Field6, InputType as InputType6 } from "type-graphql";
+function _ts_decorate6(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_decorate6, "_ts_decorate");
+function _ts_metadata6(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
+    return Reflect.metadata(k, v);
+}
+__name(_ts_metadata6, "_ts_metadata");
+var ForwardedParametersInput = class {
+  model;
+  maxTokens;
+  stop;
+  toolChoice;
+  toolChoiceFunctionName;
+  temperature;
+};
+__name(ForwardedParametersInput, "ForwardedParametersInput");
+_ts_decorate6([
+  Field6(() => String, {
+    nullable: true
+  }),
+  _ts_metadata6("design:type", String)
+], ForwardedParametersInput.prototype, "model", void 0);
+_ts_decorate6([
+  Field6(() => Number, {
+    nullable: true
+  }),
+  _ts_metadata6("design:type", Number)
+], ForwardedParametersInput.prototype, "maxTokens", void 0);
+_ts_decorate6([
+  Field6(() => [
+    String
+  ], {
+    nullable: true
+  }),
+  _ts_metadata6("design:type", Array)
+], ForwardedParametersInput.prototype, "stop", void 0);
+_ts_decorate6([
+  Field6(() => String, {
+    nullable: true
+  }),
+  _ts_metadata6("design:type", typeof String === "undefined" ? Object : String)
+], ForwardedParametersInput.prototype, "toolChoice", void 0);
+_ts_decorate6([
+  Field6(() => String, {
+    nullable: true
+  }),
+  _ts_metadata6("design:type", String)
+], ForwardedParametersInput.prototype, "toolChoiceFunctionName", void 0);
+_ts_decorate6([
+  Field6(() => Number, {
+    nullable: true
+  }),
+  _ts_metadata6("design:type", Number)
+], ForwardedParametersInput.prototype, "temperature", void 0);
+ForwardedParametersInput = _ts_decorate6([
+  InputType6()
+], ForwardedParametersInput);
+
+// src/graphql/inputs/agent-session.input.ts
+import { Field as Field7, InputType as InputType7 } from "type-graphql";
+function _ts_decorate7(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_decorate7, "_ts_decorate");
+function _ts_metadata7(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
+    return Reflect.metadata(k, v);
+}
+__name(_ts_metadata7, "_ts_metadata");
+var AgentSessionInput = class {
+  agentName;
+  threadId;
+  nodeName;
+};
+__name(AgentSessionInput, "AgentSessionInput");
+_ts_decorate7([
+  Field7(() => String),
+  _ts_metadata7("design:type", String)
+], AgentSessionInput.prototype, "agentName", void 0);
+_ts_decorate7([
+  Field7(() => String, {
+    nullable: true
+  }),
+  _ts_metadata7("design:type", String)
+], AgentSessionInput.prototype, "threadId", void 0);
+_ts_decorate7([
+  Field7(() => String, {
+    nullable: true
+  }),
+  _ts_metadata7("design:type", String)
+], AgentSessionInput.prototype, "nodeName", void 0);
+AgentSessionInput = _ts_decorate7([
+  InputType7()
+], AgentSessionInput);
+
+// src/graphql/inputs/agent-state.input.ts
+import { Field as Field8, InputType as InputType8 } from "type-graphql";
+function _ts_decorate8(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_decorate8, "_ts_decorate");
+function _ts_metadata8(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
+    return Reflect.metadata(k, v);
+}
+__name(_ts_metadata8, "_ts_metadata");
+var AgentStateInput = class {
+  agentName;
+  state;
+  config;
+};
+__name(AgentStateInput, "AgentStateInput");
+_ts_decorate8([
+  Field8(() => String),
+  _ts_metadata8("design:type", String)
+], AgentStateInput.prototype, "agentName", void 0);
+_ts_decorate8([
+  Field8(() => String),
+  _ts_metadata8("design:type", String)
+], AgentStateInput.prototype, "state", void 0);
+_ts_decorate8([
+  Field8(() => String, {
+    nullable: true
+  }),
+  _ts_metadata8("design:type", String)
+], AgentStateInput.prototype, "config", void 0);
+AgentStateInput = _ts_decorate8([
+  InputType8()
+], AgentStateInput);
+
+// src/graphql/inputs/extensions.input.ts
+import { Field as Field9, InputType as InputType9 } from "type-graphql";
+function _ts_decorate9(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_decorate9, "_ts_decorate");
+function _ts_metadata9(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
+    return Reflect.metadata(k, v);
+}
+__name(_ts_metadata9, "_ts_metadata");
+var ExtensionsInput = class {
+  openaiAssistantAPI;
+};
+__name(ExtensionsInput, "ExtensionsInput");
+_ts_decorate9([
+  Field9(() => OpenAIApiAssistantAPIInput, {
+    nullable: true
+  }),
+  _ts_metadata9("design:type", typeof OpenAIApiAssistantAPIInput === "undefined" ? Object : OpenAIApiAssistantAPIInput)
+], ExtensionsInput.prototype, "openaiAssistantAPI", void 0);
+ExtensionsInput = _ts_decorate9([
+  InputType9()
+], ExtensionsInput);
+var OpenAIApiAssistantAPIInput = class {
+  runId;
+  threadId;
+};
+__name(OpenAIApiAssistantAPIInput, "OpenAIApiAssistantAPIInput");
+_ts_decorate9([
+  Field9(() => String, {
+    nullable: true
+  }),
+  _ts_metadata9("design:type", String)
+], OpenAIApiAssistantAPIInput.prototype, "runId", void 0);
+_ts_decorate9([
+  Field9(() => String, {
+    nullable: true
+  }),
+  _ts_metadata9("design:type", String)
+], OpenAIApiAssistantAPIInput.prototype, "threadId", void 0);
+OpenAIApiAssistantAPIInput = _ts_decorate9([
+  InputType9()
+], OpenAIApiAssistantAPIInput);
+
+// src/graphql/inputs/meta-event.input.ts
+import { Field as Field13, InputType as InputType10 } from "type-graphql";
+
+// src/graphql/types/meta-events.type.ts
+import { Field as Field12, InterfaceType as InterfaceType2, ObjectType as ObjectType3, registerEnumType } from "type-graphql";
+
+// src/graphql/types/copilot-response.type.ts
+import { Field as Field11, InterfaceType, ObjectType as ObjectType2 } from "type-graphql";
+
+// src/graphql/types/extensions-response.type.ts
+import { Field as Field10, ObjectType } from "type-graphql";
+function _ts_decorate10(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_decorate10, "_ts_decorate");
+function _ts_metadata10(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
+    return Reflect.metadata(k, v);
+}
+__name(_ts_metadata10, "_ts_metadata");
+var ExtensionsResponse = class {
+  openaiAssistantAPI;
+};
+__name(ExtensionsResponse, "ExtensionsResponse");
+_ts_decorate10([
+  Field10(() => OpenAIApiAssistantAPIResponse, {
+    nullable: true
+  }),
+  _ts_metadata10("design:type", typeof OpenAIApiAssistantAPIResponse === "undefined" ? Object : OpenAIApiAssistantAPIResponse)
+], ExtensionsResponse.prototype, "openaiAssistantAPI", void 0);
+ExtensionsResponse = _ts_decorate10([
+  ObjectType()
+], ExtensionsResponse);
+var OpenAIApiAssistantAPIResponse = class {
+  runId;
+  threadId;
+};
+__name(OpenAIApiAssistantAPIResponse, "OpenAIApiAssistantAPIResponse");
+_ts_decorate10([
+  Field10(() => String, {
+    nullable: true
+  }),
+  _ts_metadata10("design:type", String)
+], OpenAIApiAssistantAPIResponse.prototype, "runId", void 0);
+_ts_decorate10([
+  Field10(() => String, {
+    nullable: true
+  }),
+  _ts_metadata10("design:type", String)
+], OpenAIApiAssistantAPIResponse.prototype, "threadId", void 0);
+OpenAIApiAssistantAPIResponse = _ts_decorate10([
+  ObjectType()
+], OpenAIApiAssistantAPIResponse);
+
+// src/graphql/types/copilot-response.type.ts
+function _ts_decorate11(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_decorate11, "_ts_decorate");
+function _ts_metadata11(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
+    return Reflect.metadata(k, v);
+}
+__name(_ts_metadata11, "_ts_metadata");
+var BaseMessageOutput = class {
+  id;
+  createdAt;
+  status;
+};
+__name(BaseMessageOutput, "BaseMessageOutput");
+_ts_decorate11([
+  Field11(() => String),
+  _ts_metadata11("design:type", String)
+], BaseMessageOutput.prototype, "id", void 0);
+_ts_decorate11([
+  Field11(() => Date),
+  _ts_metadata11("design:type", typeof Date === "undefined" ? Object : Date)
+], BaseMessageOutput.prototype, "createdAt", void 0);
+_ts_decorate11([
+  Field11(() => MessageStatusUnion),
+  _ts_metadata11("design:type", Object)
+], BaseMessageOutput.prototype, "status", void 0);
+BaseMessageOutput = _ts_decorate11([
+  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 void 0;
+    }
+  })
+], BaseMessageOutput);
+var TextMessageOutput = class {
+  role;
+  content;
+  parentMessageId;
+};
+__name(TextMessageOutput, "TextMessageOutput");
+_ts_decorate11([
+  Field11(() => MessageRole),
+  _ts_metadata11("design:type", typeof MessageRole === "undefined" ? Object : MessageRole)
+], TextMessageOutput.prototype, "role", void 0);
+_ts_decorate11([
+  Field11(() => [
+    String
+  ]),
+  _ts_metadata11("design:type", Array)
+], TextMessageOutput.prototype, "content", void 0);
+_ts_decorate11([
+  Field11(() => String, {
+    nullable: true
+  }),
+  _ts_metadata11("design:type", String)
+], TextMessageOutput.prototype, "parentMessageId", void 0);
+TextMessageOutput = _ts_decorate11([
+  ObjectType2({
+    implements: BaseMessageOutput
+  })
+], TextMessageOutput);
+var ActionExecutionMessageOutput = class {
+  name;
+  scope;
+  arguments;
+  parentMessageId;
+};
+__name(ActionExecutionMessageOutput, "ActionExecutionMessageOutput");
+_ts_decorate11([
+  Field11(() => String),
+  _ts_metadata11("design:type", String)
+], ActionExecutionMessageOutput.prototype, "name", void 0);
+_ts_decorate11([
+  Field11(() => String, {
+    nullable: true,
+    deprecationReason: "This field will be removed in a future version"
+  }),
+  _ts_metadata11("design:type", String)
+], ActionExecutionMessageOutput.prototype, "scope", void 0);
+_ts_decorate11([
+  Field11(() => [
+    String
+  ]),
+  _ts_metadata11("design:type", Array)
+], ActionExecutionMessageOutput.prototype, "arguments", void 0);
+_ts_decorate11([
+  Field11(() => String, {
+    nullable: true
+  }),
+  _ts_metadata11("design:type", String)
+], ActionExecutionMessageOutput.prototype, "parentMessageId", void 0);
+ActionExecutionMessageOutput = _ts_decorate11([
+  ObjectType2({
+    implements: BaseMessageOutput
+  })
+], ActionExecutionMessageOutput);
+var ResultMessageOutput = class {
+  actionExecutionId;
+  actionName;
+  result;
+};
+__name(ResultMessageOutput, "ResultMessageOutput");
+_ts_decorate11([
+  Field11(() => String),
+  _ts_metadata11("design:type", String)
+], ResultMessageOutput.prototype, "actionExecutionId", void 0);
+_ts_decorate11([
+  Field11(() => String),
+  _ts_metadata11("design:type", String)
+], ResultMessageOutput.prototype, "actionName", void 0);
+_ts_decorate11([
+  Field11(() => String),
+  _ts_metadata11("design:type", String)
+], ResultMessageOutput.prototype, "result", void 0);
+ResultMessageOutput = _ts_decorate11([
+  ObjectType2({
+    implements: BaseMessageOutput
+  })
+], ResultMessageOutput);
+var AgentStateMessageOutput = class {
+  threadId;
+  agentName;
+  nodeName;
+  runId;
+  active;
+  role;
+  state;
+  running;
+};
+__name(AgentStateMessageOutput, "AgentStateMessageOutput");
+_ts_decorate11([
+  Field11(() => String),
+  _ts_metadata11("design:type", String)
+], AgentStateMessageOutput.prototype, "threadId", void 0);
+_ts_decorate11([
+  Field11(() => String),
+  _ts_metadata11("design:type", String)
+], AgentStateMessageOutput.prototype, "agentName", void 0);
+_ts_decorate11([
+  Field11(() => String),
+  _ts_metadata11("design:type", String)
+], AgentStateMessageOutput.prototype, "nodeName", void 0);
+_ts_decorate11([
+  Field11(() => String),
+  _ts_metadata11("design:type", String)
+], AgentStateMessageOutput.prototype, "runId", void 0);
+_ts_decorate11([
+  Field11(() => Boolean),
+  _ts_metadata11("design:type", Boolean)
+], AgentStateMessageOutput.prototype, "active", void 0);
+_ts_decorate11([
+  Field11(() => MessageRole),
+  _ts_metadata11("design:type", typeof MessageRole === "undefined" ? Object : MessageRole)
+], AgentStateMessageOutput.prototype, "role", void 0);
+_ts_decorate11([
+  Field11(() => String),
+  _ts_metadata11("design:type", String)
+], AgentStateMessageOutput.prototype, "state", void 0);
+_ts_decorate11([
+  Field11(() => Boolean),
+  _ts_metadata11("design:type", Boolean)
+], AgentStateMessageOutput.prototype, "running", void 0);
+AgentStateMessageOutput = _ts_decorate11([
+  ObjectType2({
+    implements: BaseMessageOutput
+  })
+], AgentStateMessageOutput);
+var ImageMessageOutput = class {
+  format;
+  bytes;
+  role;
+  parentMessageId;
+};
+__name(ImageMessageOutput, "ImageMessageOutput");
+_ts_decorate11([
+  Field11(() => String),
+  _ts_metadata11("design:type", String)
+], ImageMessageOutput.prototype, "format", void 0);
+_ts_decorate11([
+  Field11(() => String),
+  _ts_metadata11("design:type", String)
+], ImageMessageOutput.prototype, "bytes", void 0);
+_ts_decorate11([
+  Field11(() => MessageRole),
+  _ts_metadata11("design:type", typeof MessageRole === "undefined" ? Object : MessageRole)
+], ImageMessageOutput.prototype, "role", void 0);
+_ts_decorate11([
+  Field11(() => String, {
+    nullable: true
+  }),
+  _ts_metadata11("design:type", String)
+], ImageMessageOutput.prototype, "parentMessageId", void 0);
+ImageMessageOutput = _ts_decorate11([
+  ObjectType2({
+    implements: BaseMessageOutput
+  })
+], ImageMessageOutput);
+var CopilotResponse = class {
+  threadId;
+  status;
+  runId;
+  messages;
+  extensions;
+  metaEvents;
+};
+__name(CopilotResponse, "CopilotResponse");
+_ts_decorate11([
+  Field11(() => String),
+  _ts_metadata11("design:type", String)
+], CopilotResponse.prototype, "threadId", void 0);
+_ts_decorate11([
+  Field11(() => ResponseStatusUnion),
+  _ts_metadata11("design:type", Object)
+], CopilotResponse.prototype, "status", void 0);
+_ts_decorate11([
+  Field11({
+    nullable: true
+  }),
+  _ts_metadata11("design:type", String)
+], CopilotResponse.prototype, "runId", void 0);
+_ts_decorate11([
+  Field11(() => [
+    BaseMessageOutput
+  ]),
+  _ts_metadata11("design:type", Array)
+], CopilotResponse.prototype, "messages", void 0);
+_ts_decorate11([
+  Field11(() => ExtensionsResponse, {
+    nullable: true
+  }),
+  _ts_metadata11("design:type", typeof ExtensionsResponse === "undefined" ? Object : ExtensionsResponse)
+], CopilotResponse.prototype, "extensions", void 0);
+_ts_decorate11([
+  Field11(() => [
+    BaseMetaEvent
+  ], {
+    nullable: true
+  }),
+  _ts_metadata11("design:type", Array)
+], CopilotResponse.prototype, "metaEvents", void 0);
+CopilotResponse = _ts_decorate11([
+  ObjectType2()
+], CopilotResponse);
+
+// src/graphql/types/meta-events.type.ts
+function _ts_decorate12(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_decorate12, "_ts_decorate");
+function _ts_metadata12(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
+    return Reflect.metadata(k, v);
+}
+__name(_ts_metadata12, "_ts_metadata");
+var MetaEventName;
+(function(MetaEventName2) {
+  MetaEventName2["LangGraphInterruptEvent"] = "LangGraphInterruptEvent";
+  MetaEventName2["CopilotKitLangGraphInterruptEvent"] = "CopilotKitLangGraphInterruptEvent";
+})(MetaEventName || (MetaEventName = {}));
+registerEnumType(MetaEventName, {
+  name: "MetaEventName",
+  description: "Meta event types"
+});
+var BaseMetaEvent = class {
+  type = "MetaEvent";
+  name;
+};
+__name(BaseMetaEvent, "BaseMetaEvent");
+_ts_decorate12([
+  Field12(() => String),
+  _ts_metadata12("design:type", String)
+], BaseMetaEvent.prototype, "type", void 0);
+_ts_decorate12([
+  Field12(() => MetaEventName),
+  _ts_metadata12("design:type", String)
+], BaseMetaEvent.prototype, "name", void 0);
+BaseMetaEvent = _ts_decorate12([
+  InterfaceType2({
+    resolveType(value) {
+      if (value.name === "LangGraphInterruptEvent") {
+        return LangGraphInterruptEvent;
+      } else if (value.name === "CopilotKitLangGraphInterruptEvent") {
+        return CopilotKitLangGraphInterruptEvent;
+      }
+      return void 0;
+    }
+  }),
+  InterfaceType2()
+], BaseMetaEvent);
+var CopilotKitLangGraphInterruptEventData = class {
+  value;
+  messages;
+};
+__name(CopilotKitLangGraphInterruptEventData, "CopilotKitLangGraphInterruptEventData");
+_ts_decorate12([
+  Field12(() => String),
+  _ts_metadata12("design:type", String)
+], CopilotKitLangGraphInterruptEventData.prototype, "value", void 0);
+_ts_decorate12([
+  Field12(() => [
+    BaseMessageOutput
+  ]),
+  _ts_metadata12("design:type", Array)
+], CopilotKitLangGraphInterruptEventData.prototype, "messages", void 0);
+CopilotKitLangGraphInterruptEventData = _ts_decorate12([
+  ObjectType3()
+], CopilotKitLangGraphInterruptEventData);
+var LangGraphInterruptEvent = class {
+  name = "LangGraphInterruptEvent";
+  value;
+  response;
+};
+__name(LangGraphInterruptEvent, "LangGraphInterruptEvent");
+_ts_decorate12([
+  Field12(() => MetaEventName),
+  _ts_metadata12("design:type", typeof MetaEventName === "undefined" || false ? Object : "LangGraphInterruptEvent")
+], LangGraphInterruptEvent.prototype, "name", void 0);
+_ts_decorate12([
+  Field12(() => String),
+  _ts_metadata12("design:type", String)
+], LangGraphInterruptEvent.prototype, "value", void 0);
+_ts_decorate12([
+  Field12(() => String, {
+    nullable: true
+  }),
+  _ts_metadata12("design:type", String)
+], LangGraphInterruptEvent.prototype, "response", void 0);
+LangGraphInterruptEvent = _ts_decorate12([
+  ObjectType3({
+    implements: BaseMetaEvent
+  })
+], LangGraphInterruptEvent);
+var CopilotKitLangGraphInterruptEvent = class {
+  name = "CopilotKitLangGraphInterruptEvent";
+  data;
+  response;
+};
+__name(CopilotKitLangGraphInterruptEvent, "CopilotKitLangGraphInterruptEvent");
+_ts_decorate12([
+  Field12(() => MetaEventName),
+  _ts_metadata12("design:type", typeof MetaEventName === "undefined" || false ? Object : "CopilotKitLangGraphInterruptEvent")
+], CopilotKitLangGraphInterruptEvent.prototype, "name", void 0);
+_ts_decorate12([
+  Field12(() => CopilotKitLangGraphInterruptEventData),
+  _ts_metadata12("design:type", typeof CopilotKitLangGraphInterruptEventData === "undefined" ? Object : CopilotKitLangGraphInterruptEventData)
+], CopilotKitLangGraphInterruptEvent.prototype, "data", void 0);
+_ts_decorate12([
+  Field12(() => String, {
+    nullable: true
+  }),
+  _ts_metadata12("design:type", String)
+], CopilotKitLangGraphInterruptEvent.prototype, "response", void 0);
+CopilotKitLangGraphInterruptEvent = _ts_decorate12([
+  ObjectType3({
+    implements: BaseMetaEvent
+  })
+], CopilotKitLangGraphInterruptEvent);
+
+// src/graphql/inputs/meta-event.input.ts
+function _ts_decorate13(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_decorate13, "_ts_decorate");
+function _ts_metadata13(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
+    return Reflect.metadata(k, v);
+}
+__name(_ts_metadata13, "_ts_metadata");
+var MetaEventInput = class {
+  name;
+  value;
+  response;
+  messages;
+};
+__name(MetaEventInput, "MetaEventInput");
+_ts_decorate13([
+  Field13(() => MetaEventName),
+  _ts_metadata13("design:type", typeof MetaEventName === "undefined" ? Object : MetaEventName)
+], MetaEventInput.prototype, "name", void 0);
+_ts_decorate13([
+  Field13(() => String),
+  _ts_metadata13("design:type", String)
+], MetaEventInput.prototype, "value", void 0);
+_ts_decorate13([
+  Field13(() => String, {
+    nullable: true
+  }),
+  _ts_metadata13("design:type", String)
+], MetaEventInput.prototype, "response", void 0);
+_ts_decorate13([
+  Field13(() => [
+    MessageInput
+  ], {
+    nullable: true
+  }),
+  _ts_metadata13("design:type", Array)
+], MetaEventInput.prototype, "messages", void 0);
+MetaEventInput = _ts_decorate13([
+  InputType10()
+], MetaEventInput);
+
+// src/graphql/inputs/copilot-context.input.ts
+import { Field as Field14, InputType as InputType11 } from "type-graphql";
+function _ts_decorate14(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_decorate14, "_ts_decorate");
+function _ts_metadata14(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
+    return Reflect.metadata(k, v);
+}
+__name(_ts_metadata14, "_ts_metadata");
+var CopilotContextInput = class {
+  description;
+  value;
+};
+__name(CopilotContextInput, "CopilotContextInput");
+_ts_decorate14([
+  Field14(() => String),
+  _ts_metadata14("design:type", String)
+], CopilotContextInput.prototype, "description", void 0);
+_ts_decorate14([
+  Field14(() => String),
+  _ts_metadata14("design:type", String)
+], CopilotContextInput.prototype, "value", void 0);
+CopilotContextInput = _ts_decorate14([
+  InputType11()
+], CopilotContextInput);
+
+// src/graphql/inputs/generate-copilot-response.input.ts
+function _ts_decorate15(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_decorate15, "_ts_decorate");
+function _ts_metadata15(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
+    return Reflect.metadata(k, v);
+}
+__name(_ts_metadata15, "_ts_metadata");
+var GenerateCopilotResponseMetadataInput = class {
+  requestType;
+};
+__name(GenerateCopilotResponseMetadataInput, "GenerateCopilotResponseMetadataInput");
+_ts_decorate15([
+  Field15(() => CopilotRequestType, {
+    nullable: true
+  }),
+  _ts_metadata15("design:type", typeof CopilotRequestType === "undefined" ? Object : CopilotRequestType)
+], GenerateCopilotResponseMetadataInput.prototype, "requestType", void 0);
+GenerateCopilotResponseMetadataInput = _ts_decorate15([
+  InputType12()
+], GenerateCopilotResponseMetadataInput);
+var GenerateCopilotResponseInput = class {
+  metadata;
+  threadId;
+  runId;
+  messages;
+  frontend;
+  cloud;
+  forwardedParameters;
+  agentSession;
+  agentState;
+  agentStates;
+  extensions;
+  metaEvents;
+  context;
+};
+__name(GenerateCopilotResponseInput, "GenerateCopilotResponseInput");
+_ts_decorate15([
+  Field15(() => GenerateCopilotResponseMetadataInput, {
+    nullable: false
+  }),
+  _ts_metadata15("design:type", typeof GenerateCopilotResponseMetadataInput === "undefined" ? Object : GenerateCopilotResponseMetadataInput)
+], GenerateCopilotResponseInput.prototype, "metadata", void 0);
+_ts_decorate15([
+  Field15(() => String, {
+    nullable: true
+  }),
+  _ts_metadata15("design:type", String)
+], GenerateCopilotResponseInput.prototype, "threadId", void 0);
+_ts_decorate15([
+  Field15(() => String, {
+    nullable: true
+  }),
+  _ts_metadata15("design:type", String)
+], GenerateCopilotResponseInput.prototype, "runId", void 0);
+_ts_decorate15([
+  Field15(() => [
+    MessageInput
+  ]),
+  _ts_metadata15("design:type", Array)
+], GenerateCopilotResponseInput.prototype, "messages", void 0);
+_ts_decorate15([
+  Field15(() => FrontendInput),
+  _ts_metadata15("design:type", typeof FrontendInput === "undefined" ? Object : FrontendInput)
+], GenerateCopilotResponseInput.prototype, "frontend", void 0);
+_ts_decorate15([
+  Field15(() => CloudInput, {
+    nullable: true
+  }),
+  _ts_metadata15("design:type", typeof CloudInput === "undefined" ? Object : CloudInput)
+], GenerateCopilotResponseInput.prototype, "cloud", void 0);
+_ts_decorate15([
+  Field15(() => ForwardedParametersInput, {
+    nullable: true
+  }),
+  _ts_metadata15("design:type", typeof ForwardedParametersInput === "undefined" ? Object : ForwardedParametersInput)
+], GenerateCopilotResponseInput.prototype, "forwardedParameters", void 0);
+_ts_decorate15([
+  Field15(() => AgentSessionInput, {
+    nullable: true
+  }),
+  _ts_metadata15("design:type", typeof AgentSessionInput === "undefined" ? Object : AgentSessionInput)
+], GenerateCopilotResponseInput.prototype, "agentSession", void 0);
+_ts_decorate15([
+  Field15(() => AgentStateInput, {
+    nullable: true
+  }),
+  _ts_metadata15("design:type", typeof AgentStateInput === "undefined" ? Object : AgentStateInput)
+], GenerateCopilotResponseInput.prototype, "agentState", void 0);
+_ts_decorate15([
+  Field15(() => [
+    AgentStateInput
+  ], {
+    nullable: true
+  }),
+  _ts_metadata15("design:type", Array)
+], GenerateCopilotResponseInput.prototype, "agentStates", void 0);
+_ts_decorate15([
+  Field15(() => ExtensionsInput, {
+    nullable: true
+  }),
+  _ts_metadata15("design:type", typeof ExtensionsInput === "undefined" ? Object : ExtensionsInput)
+], GenerateCopilotResponseInput.prototype, "extensions", void 0);
+_ts_decorate15([
+  Field15(() => [
+    MetaEventInput
+  ], {
+    nullable: true
+  }),
+  _ts_metadata15("design:type", Array)
+], GenerateCopilotResponseInput.prototype, "metaEvents", void 0);
+_ts_decorate15([
+  Field15(() => [
+    CopilotContextInput
+  ], {
+    nullable: true
+  }),
+  _ts_metadata15("design:type", Array)
+], GenerateCopilotResponseInput.prototype, "context", void 0);
+GenerateCopilotResponseInput = _ts_decorate15([
+  InputType12()
+], GenerateCopilotResponseInput);
+
+// src/graphql/resolvers/copilot.resolver.ts
+import { Repeater } from "graphql-yoga";
+
+// src/service-adapters/events.ts
+import { CopilotKitError, CopilotKitErrorCode, CopilotKitLowLevelError, Severity } from "@copilotkit/shared";
+import { ReplaySubject } from "rxjs";
+var RuntimeEventTypes;
+(function(RuntimeEventTypes2) {
+  RuntimeEventTypes2["TextMessageStart"] = "TextMessageStart";
+  RuntimeEventTypes2["TextMessageContent"] = "TextMessageContent";
+  RuntimeEventTypes2["TextMessageEnd"] = "TextMessageEnd";
+  RuntimeEventTypes2["ActionExecutionStart"] = "ActionExecutionStart";
+  RuntimeEventTypes2["ActionExecutionArgs"] = "ActionExecutionArgs";
+  RuntimeEventTypes2["ActionExecutionEnd"] = "ActionExecutionEnd";
+  RuntimeEventTypes2["ActionExecutionResult"] = "ActionExecutionResult";
+  RuntimeEventTypes2["AgentStateMessage"] = "AgentStateMessage";
+  RuntimeEventTypes2["MetaEvent"] = "MetaEvent";
+  RuntimeEventTypes2["RunError"] = "RunError";
+})(RuntimeEventTypes || (RuntimeEventTypes = {}));
+var RuntimeMetaEventName;
+(function(RuntimeMetaEventName2) {
+  RuntimeMetaEventName2["LangGraphInterruptEvent"] = "LangGraphInterruptEvent";
+  RuntimeMetaEventName2["LangGraphInterruptResumeEvent"] = "LangGraphInterruptResumeEvent";
+  RuntimeMetaEventName2["CopilotKitLangGraphInterruptEvent"] = "CopilotKitLangGraphInterruptEvent";
+})(RuntimeMetaEventName || (RuntimeMetaEventName = {}));
+
+// src/graphql/resolvers/copilot.resolver.ts
+import { GraphQLJSONObject } from "graphql-scalars";
+import { plainToInstance } from "class-transformer";
+import { GraphQLError } from "graphql";
+
+// src/lib/telemetry-client.ts
+import { TelemetryClient } from "@copilotkit/shared";
+import { createHash } from "crypto";
+
+// src/lib/runtime/copilot-runtime.ts
+import { CopilotKitMisuseError, readBody, getZodParameters } from "@copilotkit/shared";
+import { CopilotRuntime as CopilotRuntimeVNext, InMemoryAgentRunner as InMemoryAgentRunnerVNext } from "@copilotkitnext/runtime";
+
+// src/lib/runtime/types.ts
+var EndpointType;
+(function(EndpointType2) {
+  EndpointType2["CopilotKit"] = "copilotKit";
+  EndpointType2["LangGraphPlatform"] = "langgraph-platform";
+})(EndpointType || (EndpointType = {}));
+
+// src/lib/runtime/mcp-tools-utils.ts
+function extractParametersFromSchema(toolOrSchema) {
+  var _a;
+  const parameters = [];
+  const schema = "schema" in (toolOrSchema || {}) ? toolOrSchema.schema : toolOrSchema;
+  const toolParameters = ((_a = schema == null ? void 0 : schema.parameters) == null ? void 0 : _a.jsonSchema) || (schema == null ? void 0 : schema.parameters);
+  const properties = toolParameters == null ? void 0 : toolParameters.properties;
+  const requiredParams = new Set((toolParameters == null ? void 0 : toolParameters.required) || []);
+  if (!properties) {
+    return parameters;
+  }
+  for (const paramName in properties) {
+    if (Object.prototype.hasOwnProperty.call(properties, paramName)) {
+      const paramDef = properties[paramName];
+      let type = paramDef.type || "string";
+      let description = paramDef.description || "";
+      if (type === "array" && paramDef.items) {
+        const itemType = paramDef.items.type || "object";
+        if (itemType === "object" && paramDef.items.properties) {
+          const itemProperties = Object.keys(paramDef.items.properties).join(", ");
+          description = description + (description ? " " : "") + `Array of objects with properties: ${itemProperties}`;
+        } else {
+          type = `array<${itemType}>`;
+        }
+      }
+      if (paramDef.enum && Array.isArray(paramDef.enum)) {
+        const enumValues = paramDef.enum.join(" | ");
+        description = description + (description ? " " : "") + `Allowed values: ${enumValues}`;
+      }
+      if (type === "object" && paramDef.properties) {
+        const objectProperties = Object.keys(paramDef.properties).join(", ");
+        description = description + (description ? " " : "") + `Object with properties: ${objectProperties}`;
+      }
+      parameters.push({
+        name: paramName,
+        type,
+        description,
+        required: requiredParams.has(paramName)
+      });
+    }
+  }
+  return parameters;
+}
+__name(extractParametersFromSchema, "extractParametersFromSchema");
+function convertMCPToolsToActions(mcpTools, mcpEndpoint) {
+  const actions = [];
+  for (const [toolName, tool] of Object.entries(mcpTools)) {
+    const parameters = extractParametersFromSchema(tool);
+    const handler = /* @__PURE__ */ __name(async (params) => {
+      try {
+        const result = await tool.execute(params);
+        return typeof result === "string" ? result : JSON.stringify(result);
+      } catch (error) {
+        console.error(`Error executing MCP tool '${toolName}' from endpoint ${mcpEndpoint}:`, error);
+        throw new Error(`Execution failed for MCP tool '${toolName}': ${error instanceof Error ? error.message : String(error)}`);
+      }
+    }, "handler");
+    actions.push({
+      name: toolName,
+      description: tool.description || `MCP tool: ${toolName} (from ${mcpEndpoint})`,
+      parameters,
+      handler,
+      // Add metadata for easier identification/debugging
+      _isMCPTool: true,
+      _mcpEndpoint: mcpEndpoint
+    });
+  }
+  return actions;
+}
+__name(convertMCPToolsToActions, "convertMCPToolsToActions");
+function generateMcpToolInstructions(toolsMap) {
+  if (!toolsMap || Object.keys(toolsMap).length === 0) {
+    return "";
+  }
+  const toolEntries = Object.entries(toolsMap);
+  const toolsDoc = toolEntries.map(([name, tool]) => {
+    var _a;
+    let paramsDoc = "    No parameters required";
+    try {
+      if (tool.schema && typeof tool.schema === "object") {
+        const schema = tool.schema;
+        const toolParameters = ((_a = schema.parameters) == null ? void 0 : _a.jsonSchema) || schema.parameters;
+        const properties = (toolParameters == null ? void 0 : toolParameters.properties) || schema.properties;
+        const requiredParams = (toolParameters == null ? void 0 : toolParameters.required) || schema.required || [];
+        if (properties) {
+          const paramsList = Object.entries(properties).map(([paramName, propSchema]) => {
+            const propDetails = propSchema;
+            const requiredMark = requiredParams.includes(paramName) ? "*" : "";
+            let typeInfo = propDetails.type || "any";
+            let description = propDetails.description ? ` - ${propDetails.description}` : "";
+            if (typeInfo === "array" && propDetails.items) {
+              const itemType = propDetails.items.type || "object";
+              if (itemType === "object" && propDetails.items.properties) {
+                const itemProps = Object.keys(propDetails.items.properties).join(", ");
+                typeInfo = `array<object>`;
+                description = description + (description ? " " : " - ") + `Array of objects with properties: ${itemProps}`;
+              } else {
+                typeInfo = `array<${itemType}>`;
+              }
+            }
+            if (propDetails.enum && Array.isArray(propDetails.enum)) {
+              const enumValues = propDetails.enum.join(" | ");
+              description = description + (description ? " " : " - ") + `Allowed values: ${enumValues}`;
+            }
+            if (typeInfo === "object" && propDetails.properties) {
+              const objectProps = Object.keys(propDetails.properties).join(", ");
+              description = description + (description ? " " : " - ") + `Object with properties: ${objectProps}`;
+            }
+            return `    - ${paramName}${requiredMark} (${typeInfo})${description}`;
+          });
+          if (paramsList.length > 0) {
+            paramsDoc = paramsList.join("\n");
+          }
+        }
+      }
+    } catch (e) {
+      console.error(`Error parsing schema for tool ${name}:`, e);
+    }
+    return `- ${name}: ${tool.description || ""}
+${paramsDoc}`;
+  }).join("\n\n");
+  return `You have access to the following external tools provided by Model Context Protocol (MCP) servers:
+
+${toolsDoc}
+
+When using these tools:
+1. Only provide valid parameters according to their type requirements
+2. Required parameters are marked with *
+3. For array parameters, provide data in the correct array format
+4. For object parameters, include all required nested properties
+5. For enum parameters, use only the allowed values listed
+6. Format API calls correctly with the expected parameter structure
+7. Always check tool responses to determine your next action`;
+}
+__name(generateMcpToolInstructions, "generateMcpToolInstructions");
+
+// src/lib/runtime/agent-integrations/langgraph.agent.ts
+import { EventType } from "@ag-ui/client";
+import { map } from "rxjs";
+
+// src/agents/langgraph/events.ts
+var LangGraphEventTypes;
+(function(LangGraphEventTypes2) {
+  LangGraphEventTypes2["OnChainStart"] = "on_chain_start";
+  LangGraphEventTypes2["OnChainStream"] = "on_chain_stream";
+  LangGraphEventTypes2["OnChainEnd"] = "on_chain_end";
+  LangGraphEventTypes2["OnChatModelStart"] = "on_chat_model_start";
+  LangGraphEventTypes2["OnChatModelStream"] = "on_chat_model_stream";
+  LangGraphEventTypes2["OnChatModelEnd"] = "on_chat_model_end";
+  LangGraphEventTypes2["OnToolStart"] = "on_tool_start";
+  LangGraphEventTypes2["OnToolEnd"] = "on_tool_end";
+  LangGraphEventTypes2["OnCopilotKitStateSync"] = "on_copilotkit_state_sync";
+  LangGraphEventTypes2["OnCopilotKitEmitMessage"] = "on_copilotkit_emit_message";
+  LangGraphEventTypes2["OnCopilotKitEmitToolCall"] = "on_copilotkit_emit_tool_call";
+  LangGraphEventTypes2["OnCustomEvent"] = "on_custom_event";
+  LangGraphEventTypes2["OnInterrupt"] = "on_interrupt";
+  LangGraphEventTypes2["OnCopilotKitInterrupt"] = "on_copilotkit_interrupt";
+  LangGraphEventTypes2["OnCopilotKitError"] = "on_copilotkit_error";
+})(LangGraphEventTypes || (LangGraphEventTypes = {}));
+var MetaEventNames;
+(function(MetaEventNames2) {
+  MetaEventNames2["LangGraphInterruptEvent"] = "LangGraphInterruptEvent";
+  MetaEventNames2["CopilotKitLangGraphInterruptEvent"] = "CopilotKitLangGraphInterruptEvent";
+})(MetaEventNames || (MetaEventNames = {}));
+var CustomEventNames;
+(function(CustomEventNames3) {
+  CustomEventNames3["CopilotKitManuallyEmitMessage"] = "copilotkit_manually_emit_message";
+  CustomEventNames3["CopilotKitManuallyEmitToolCall"] = "copilotkit_manually_emit_tool_call";
+  CustomEventNames3["CopilotKitManuallyEmitIntermediateState"] = "copilotkit_manually_emit_intermediate_state";
+  CustomEventNames3["CopilotKitExit"] = "copilotkit_exit";
+})(CustomEventNames || (CustomEventNames = {}));
+
+// src/lib/runtime/agent-integrations/langgraph.agent.ts
+import { LangGraphAgent as AGUILangGraphAgent, LangGraphHttpAgent } from "@ag-ui/langgraph";
+var CustomEventNames2;
+(function(CustomEventNames3) {
+  CustomEventNames3["CopilotKitManuallyEmitMessage"] = "copilotkit_manually_emit_message";
+  CustomEventNames3["CopilotKitManuallyEmitToolCall"] = "copilotkit_manually_emit_tool_call";
+  CustomEventNames3["CopilotKitManuallyEmitIntermediateState"] = "copilotkit_manually_emit_intermediate_state";
+  CustomEventNames3["CopilotKitExit"] = "copilotkit_exit";
+})(CustomEventNames2 || (CustomEventNames2 = {}));
+var LangGraphAgent = class extends AGUILangGraphAgent {
+  constructor(config) {
+    super(config);
+  }
+  // @ts-ignore
+  clone() {
+    return new LangGraphAgent(this.config);
+  }
+  dispatchEvent(event) {
+    if (event.type === EventType.CUSTOM) {
+      const customEvent = event;
+      if (customEvent.name === "copilotkit_manually_emit_message") {
+        this.subscriber.next({
+          type: EventType.TEXT_MESSAGE_START,
+          role: "assistant",
+          messageId: customEvent.value.message_id,
+          rawEvent: event
+        });
+        this.subscriber.next({
+          type: EventType.TEXT_MESSAGE_CONTENT,
+          messageId: customEvent.value.message_id,
+          delta: customEvent.value.message,
+          rawEvent: event
+        });
+        this.subscriber.next({
+          type: EventType.TEXT_MESSAGE_END,
+          messageId: customEvent.value.message_id,
+          rawEvent: event
+        });
+        return true;
+      }
+      if (customEvent.name === "copilotkit_manually_emit_tool_call") {
+        this.subscriber.next({
+          type: EventType.TOOL_CALL_START,
+          toolCallId: customEvent.value.id,
+          toolCallName: customEvent.value.name,
+          parentMessageId: customEvent.value.id,
+          rawEvent: event
+        });
+        this.subscriber.next({
+          type: EventType.TOOL_CALL_ARGS,
+          toolCallId: customEvent.value.id,
+          delta: customEvent.value.args,
+          rawEvent: event
+        });
+        this.subscriber.next({
+          type: EventType.TOOL_CALL_END,
+          toolCallId: customEvent.value.id,
+          rawEvent: event
+        });
+        return true;
+      }
+      if (customEvent.name === "copilotkit_manually_emit_intermediate_state") {
+        this.activeRun.manuallyEmittedState = customEvent.value;
+        this.dispatchEvent({
+          type: EventType.STATE_SNAPSHOT,
+          snapshot: this.getStateSnapshot({
+            values: this.activeRun.manuallyEmittedState
+          }),
+          rawEvent: event
+        });
+        return true;
+      }
+      if (customEvent.name === "copilotkit_exit") {
+        this.subscriber.next({
+          type: EventType.CUSTOM,
+          name: "Exit",
+          value: true
+        });
+        return true;
+      }
+    }
+    const rawEvent = event.rawEvent;
+    if (!rawEvent) {
+      this.subscriber.next(event);
+      return true;
+    }
+    const isMessageEvent = event.type === EventType.TEXT_MESSAGE_START || event.type === EventType.TEXT_MESSAGE_CONTENT || event.type === EventType.TEXT_MESSAGE_END;
+    const isToolEvent = event.type === EventType.TOOL_CALL_START || event.type === EventType.TOOL_CALL_ARGS || event.type === EventType.TOOL_CALL_END;
+    if ("copilotkit:emit-tool-calls" in (rawEvent.metadata || {})) {
+      if (rawEvent.metadata["copilotkit:emit-tool-calls"] === false && isToolEvent) {
+        return false;
+      }
+    }
+    if ("copilotkit:emit-messages" in (rawEvent.metadata || {})) {
+      if (rawEvent.metadata["copilotkit:emit-messages"] === false && isMessageEvent) {
+        return false;
+      }
+    }
+    this.subscriber.next(event);
+    return true;
+  }
+  // @ts-ignore
+  run(input) {
+    return super.run(input).pipe(map((processedEvent) => {
+      var _a, _b, _c, _d, _e;
+      if (processedEvent.type === EventType.RAW) {
+        const event = processedEvent.event ?? processedEvent.rawEvent;
+        const eventType = event.event;
+        const toolCallData = (_c = (_b = (_a = event.data) == null ? void 0 : _a.chunk) == null ? void 0 : _b.tool_call_chunks) == null ? void 0 : _c[0];
+        const toolCallUsedToPredictState = (_e = (_d = event.metadata) == null ? void 0 : _d["copilotkit:emit-intermediate-state"]) == null ? void 0 : _e.some((predictStateTool) => predictStateTool.tool === (toolCallData == null ? void 0 : toolCallData.name));
+        if (eventType === LangGraphEventTypes.OnChatModelStream && toolCallUsedToPredictState) {
+          return {
+            type: EventType.CUSTOM,
+            name: "PredictState",
+            value: event.metadata["copilotkit:emit-intermediate-state"]
+          };
+        }
+      }
+      return processedEvent;
+    }));
+  }
+  langGraphDefaultMergeState(state, messages, input) {
+    const aguiMergedState = super.langGraphDefaultMergeState(state, messages, input);
+    const { tools: returnedTools, "ag-ui": agui } = aguiMergedState;
+    const rawCombinedTools = [
+      ...returnedTools ?? [],
+      ...(agui == null ? void 0 : agui.tools) ?? []
+    ];
+    const combinedTools = Array.from(new Map(rawCombinedTools.map((t) => [
+      (t == null ? void 0 : t.id) ?? (t == null ? void 0 : t.name) ?? (t == null ? void 0 : t.key) ?? JSON.stringify(t),
+      t
+    ])).values());
+    return {
+      ...aguiMergedState,
+      copilotkit: {
+        actions: combinedTools,
+        context: (agui == null ? void 0 : agui.context) ?? []
+      }
+    };
+  }
+  async getSchemaKeys() {
+    const CONSTANT_KEYS = [
+      "copilotkit"
+    ];
+    const schemaKeys = await super.getSchemaKeys();
+    return {
+      config: schemaKeys.config,
+      input: schemaKeys.input ? [
+        ...schemaKeys.input,
+        ...CONSTANT_KEYS
+      ] : null,
+      output: schemaKeys.output ? [
+        ...schemaKeys.output,
+        ...CONSTANT_KEYS
+      ] : null,
+      context: schemaKeys.context ? [
+        ...schemaKeys.context,
+        ...CONSTANT_KEYS
+      ] : null
+    };
+  }
+};
+__name(LangGraphAgent, "LangGraphAgent");
+
+// src/lib/runtime/copilot-runtime.ts
+import { BasicAgent } from "@copilotkitnext/agent";
+var CopilotRuntime = class {
+  params;
+  observability;
+  // Cache MCP tools per endpoint to avoid re-fetching repeatedly
+  mcpToolsCache = /* @__PURE__ */ new Map();
+  runtimeArgs;
+  _instance;
+  constructor(params) {
+    const agents = (params == null ? void 0 : params.agents) ?? {};
+    this.runtimeArgs = {
+      agents: {
+        ...this.assignEndpointsToAgents((params == null ? void 0 : params.remoteEndpoints) ?? []),
+        ...agents
+      },
+      runner: (params == null ? void 0 : params.runner) ?? new InMemoryAgentRunnerVNext(),
+      // TODO: add support for transcriptionService from CopilotRuntimeOptionsVNext once it is ready
+      // transcriptionService: params?.transcriptionService,
+      beforeRequestMiddleware: this.createOnBeforeRequestHandler(params).bind(this),
+      afterRequestMiddleware: this.createOnAfterRequestHandler(params).bind(this)
+    };
+    this.params = params;
+    this.observability = params == null ? void 0 : params.observability_c;
+  }
+  get instance() {
+    if (!this._instance) {
+      this._instance = new CopilotRuntimeVNext(this.runtimeArgs);
+    }
+    return this._instance;
+  }
+  assignEndpointsToAgents(endpoints) {
+    return endpoints.reduce((acc, endpoint) => {
+      if (resolveEndpointType(endpoint) == EndpointType.LangGraphPlatform) {
+        let lgAgents = {};
+        const lgEndpoint = endpoint;
+        lgEndpoint.agents.forEach((agent) => {
+          const graphId = agent.assistantId ?? agent.name;
+          lgAgents[graphId] = new LangGraphAgent({
+            deploymentUrl: lgEndpoint.deploymentUrl,
+            langsmithApiKey: lgEndpoint.langsmithApiKey,
+            graphId
+          });
+        });
+        return {
+          ...acc,
+          ...lgAgents
+        };
+      }
+      return acc;
+    }, {});
+  }
+  handleServiceAdapter(serviceAdapter) {
+    this.runtimeArgs.agents = Promise.resolve(this.runtimeArgs.agents ?? {}).then(async (agents) => {
+      var _a;
+      let agentsList = agents;
+      const isAgentsListEmpty = !Object.keys(agents).length;
+      const hasServiceAdapter = Boolean(serviceAdapter);
+      const illegalServiceAdapterNames = [
+        "EmptyAdapter"
+      ];
+      const serviceAdapterCanBeUsedForAgent = !illegalServiceAdapterNames.includes(serviceAdapter.name);
+      if (isAgentsListEmpty && (!hasServiceAdapter || !serviceAdapterCanBeUsedForAgent)) {
+        throw new CopilotKitMisuseError({
+          message: "No default agent provided. Please provide a default agent in the runtime config."
+        });
+      }
+      if (isAgentsListEmpty) {
+        agentsList.default = new BasicAgent({
+          model: `${serviceAdapter.provider}/${serviceAdapter.model}`
+        });
+      }
+      if ((_a = this.params.actions) == null ? void 0 : _a.length) {
+        const mcpTools = await this.getToolsFromMCP();
+        agentsList = this.assignToolsToAgents(agents, [
+          ...this.getToolsFromActions(this.params.actions),
+          ...mcpTools
+        ]);
+      }
+      return agentsList;
+    });
+  }
+  // Receive this.params.action and turn it into the AbstractAgent tools
+  getToolsFromActions(actions) {
+    const actionsArray = typeof actions === "function" ? actions({
+      properties: {},
+      url: void 0
+    }) : actions;
+    return actionsArray.map((action) => {
+      const zodSchema = getZodParameters(action.parameters || []);
+      return {
+        name: action.name,
+        description: action.description || "",
+        parameters: zodSchema
+      };
+    });
+  }
+  assignToolsToAgents(agents, tools) {
+    if (!(tools == null ? void 0 : tools.length)) {
+      return agents;
+    }
+    const enrichedAgents = {
+      ...agents
+    };
+    for (const [agentId, agent] of Object.entries(enrichedAgents)) {
+      const existingConfig = Reflect.get(agent, "config") ?? {};
+      const existingTools = existingConfig.tools ?? [];
+      const updatedConfig = {
+        ...existingConfig,
+        tools: [
+          ...existingTools,
+          ...tools
+        ]
+      };
+      Reflect.set(agent, "config", updatedConfig);
+      enrichedAgents[agentId] = agent;
+    }
+    return enrichedAgents;
+  }
+  createOnBeforeRequestHandler(params) {
+    return async (hookParams) => {
+      var _a, _b;
+      (_a = params == null ? void 0 : params.beforeRequestMiddleware) == null ? void 0 : _a.call(params, hookParams);
+      if ((_b = params == null ? void 0 : params.middleware) == null ? void 0 : _b.onBeforeRequest) {
+        const { request, runtime, path } = hookParams;
+        const body = await readBody(request);
+        const gqlMessages = aguiToGQL(body.messages).reduce((acc, msg) => {
+          if ("role" in msg && msg.role === "user") {
+            acc.inputMessages.push(msg);
+          } else {
+            acc.outputMessages.push(msg);
+          }
+          return acc;
+        }, {
+          inputMessages: [],
+          outputMessages: []
+        });
+        const { inputMessages, outputMessages } = gqlMessages;
+        params.middleware.onBeforeRequest({
+          threadId: body.threadId,
+          runId: body.runId,
+          inputMessages,
+          properties: body.forwardedProps,
+          url: request.url
+        });
+      }
+    };
+  }
+  createOnAfterRequestHandler(params) {
+    return async (hookParams) => {
+      var _a, _b;
+      (_a = params == null ? void 0 : params.afterRequestMiddleware) == null ? void 0 : _a.call(params, hookParams);
+      if ((_b = params == null ? void 0 : params.middleware) == null ? void 0 : _b.onAfterRequest) {
+        params.middleware.onAfterRequest({});
+      }
+    };
+  }
+  // Observability Methods
+  /**
+  * Log LLM request if observability is enabled
+  */
+  async logObservabilityBeforeRequest(requestData) {
+    try {
+      await this.observability.hooks.handleRequest(requestData);
+    } catch (error) {
+      console.error("Error logging LLM request:", error);
+    }
+  }
+  /**
+  * Log final LLM response after request completes
+  */
+  logObservabilityAfterRequest(outputMessagesPromise, baseData, streamedChunks, requestStartTime, publicApiKey) {
+    try {
+      outputMessagesPromise.then((outputMessages) => {
+        const responseData = {
+          threadId: baseData.threadId,
+          runId: baseData.runId,
+          model: baseData.model,
+          // Use collected chunks for progressive mode or outputMessages for regular mode
+          output: this.observability.progressive ? streamedChunks : outputMessages,
+          latency: Date.now() - requestStartTime,
+          timestamp: Date.now(),
+          provider: baseData.provider,
+          isFinalResponse: true,
+          agentName: baseData.agentName,
+          nodeName: baseData.nodeName
+        };
+        try {
+          this.observability.hooks.handleResponse(responseData);
+        } catch (logError) {
+          console.error("Error logging LLM response:", logError);
+        }
+      }).catch((error) => {
+        console.error("Failed to get output messages for logging:", error);
+      });
+    } catch (error) {
+      console.error("Error setting up logging for LLM response:", error);
+    }
+  }
+  // Resolve MCP tools to BasicAgent tool definitions
+  // Optionally accepts request-scoped properties to merge request-provided mcpServers
+  async getToolsFromMCP(options) {
+    var _a, _b, _c, _d;
+    const runtimeMcpServers = ((_a = this.params) == null ? void 0 : _a.mcpServers) ?? [];
+    const createMCPClient = (_b = this.params) == null ? void 0 : _b.createMCPClient;
+    const requestMcpServers = ((_c = options == null ? void 0 : options.properties) == null ? void 0 : _c.mcpServers) ?? ((_d = options == null ? void 0 : options.properties) == null ? void 0 : _d.mcpEndpoints) ?? [];
+    const hasAnyServers = ((runtimeMcpServers == null ? void 0 : runtimeMcpServers.length) ?? 0) > 0 || ((requestMcpServers == null ? void 0 : requestMcpServers.length) ?? 0) > 0;
+    if (!hasAnyServers) {
+      return [];
+    }
+    if (!createMCPClient) {
+      throw new CopilotKitMisuseError({
+        message: "MCP Integration Error: `mcpServers` were provided, but the `createMCPClient` function was not passed to the CopilotRuntime constructor. Please provide an implementation for `createMCPClient`."
+      });
+    }
+    const effectiveEndpoints = (() => {
+      const byUrl = /* @__PURE__ */ new Map();
+      for (const ep of runtimeMcpServers) {
+        if (ep == null ? void 0 : ep.endpoint)
+          byUrl.set(ep.endpoint, ep);
+      }
+      for (const ep of requestMcpServers) {
+        if (ep == null ? void 0 : ep.endpoint)
+          byUrl.set(ep.endpoint, ep);
+      }
+      return Array.from(byUrl.values());
+    })();
+    const allTools = [];
+    for (const config of effectiveEndpoints) {
+      const endpointUrl = config.endpoint;
+      const cached = this.mcpToolsCache.get(endpointUrl);
+      if (cached) {
+        allTools.push(...cached);
+        continue;
+      }
+      try {
+        const client = await createMCPClient(config);
+        const toolsMap = await client.tools();
+        const toolDefs = Object.entries(toolsMap).map(([toolName, tool]) => {
+          const params = extractParametersFromSchema(tool);
+          const zodSchema = getZodParameters(params);
+          return {
+            name: toolName,
+            description: tool.description || `MCP tool: ${toolName} (from ${endpointUrl})`,
+            parameters: zodSchema
+          };
+        });
+        this.mcpToolsCache.set(endpointUrl, toolDefs);
+        allTools.push(...toolDefs);
+      } catch (error) {
+        console.error(`MCP: Failed to fetch tools from endpoint ${endpointUrl}. Skipping. Error:`, error);
+        this.mcpToolsCache.set(endpointUrl, []);
+      }
+    }
+    const dedupedByName = /* @__PURE__ */ new Map();
+    for (const tool of allTools) {
+      dedupedByName.set(tool.name, tool);
+    }
+    return Array.from(dedupedByName.values());
+  }
+};
+__name(CopilotRuntime, "CopilotRuntime");
+function copilotKitEndpoint(config) {
+  return {
+    ...config,
+    type: EndpointType.CopilotKit
+  };
+}
+__name(copilotKitEndpoint, "copilotKitEndpoint");
+function langGraphPlatformEndpoint(config) {
+  return {
+    ...config,
+    type: EndpointType.LangGraphPlatform
+  };
+}
+__name(langGraphPlatformEndpoint, "langGraphPlatformEndpoint");
+function resolveEndpointType(endpoint) {
+  if (!endpoint.type) {
+    if ("deploymentUrl" in endpoint && "agents" in endpoint) {
+      return EndpointType.LangGraphPlatform;
+    } else {
+      return EndpointType.CopilotKit;
+    }
+  }
+  return endpoint.type;
+}
+__name(resolveEndpointType, "resolveEndpointType");
+
+// src/lib/telemetry-client.ts
+var packageJson = require_package();
+var telemetryClient = new TelemetryClient({
+  packageName: packageJson.name,
+  packageVersion: packageJson.version
+});
+function getRuntimeInstanceTelemetryInfo(options) {
+  var _a, _b, _c, _d, _e;
+  const runtime = options.runtime;
+  const remoteEndpoints = ((_a = runtime.params) == null ? void 0 : _a.remoteEndpoints) ?? [];
+  const endpointsInfo = remoteEndpoints.reduce((acc, endpoint) => {
+    let info = {
+      ...acc
+    };
+    const endpointType = resolveEndpointType(endpoint);
+    if (!info.endpointTypes.includes(endpointType)) {
+      info = {
+        ...info,
+        endpointTypes: [
+          ...info.endpointTypes,
+          endpointType
+        ]
+      };
+    }
+    if (endpointType === EndpointType.LangGraphPlatform) {
+      const ep = endpoint;
+      info = {
+        ...info,
+        agentsAmount: ep.agents.length,
+        hashedKey: ep.langsmithApiKey ? createHash("sha256").update(ep.langsmithApiKey).digest("hex") : null
+      };
+    }
+    return info;
+  }, {
+    endpointTypes: [],
+    agentsAmount: null,
+    hashedKey: null
+  });
+  const publicApiKey = (_b = options.cloud) == null ? void 0 : _b.publicApiKey;
+  const apiKeyProvided = !!publicApiKey && publicApiKey.trim().length > 0;
+  return {
+    actionsAmount: ((_d = (_c = runtime.params) == null ? void 0 : _c.actions) == null ? void 0 : _d.length) ?? 0,
+    endpointsAmount: remoteEndpoints.length,
+    endpointTypes: endpointsInfo.endpointTypes,
+    agentsAmount: Object.keys(runtime.instance.agents).length,
+    hashedLgcKey: endpointsInfo.hashedKey,
+    "cloud.api_key_provided": apiKeyProvided,
+    ...apiKeyProvided ? {
+      "cloud.public_api_key": publicApiKey
+    } : {},
+    ...((_e = options.cloud) == null ? void 0 : _e.baseUrl) ? {
+      "cloud.base_url": options.cloud.baseUrl
+    } : {}
+  };
+}
+__name(getRuntimeInstanceTelemetryInfo, "getRuntimeInstanceTelemetryInfo");
+var telemetry_client_default = telemetryClient;
+
+// src/graphql/resolvers/copilot.resolver.ts
+import { randomId } from "@copilotkit/shared";
+
+// src/graphql/types/agents-response.type.ts
+import { Field as Field16, ObjectType as ObjectType4 } from "type-graphql";
+function _ts_decorate16(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_decorate16, "_ts_decorate");
+function _ts_metadata16(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
+    return Reflect.metadata(k, v);
+}
+__name(_ts_metadata16, "_ts_metadata");
+var Agent = class {
+  id;
+  name;
+  description;
+};
+__name(Agent, "Agent");
+_ts_decorate16([
+  Field16(() => String),
+  _ts_metadata16("design:type", String)
+], Agent.prototype, "id", void 0);
+_ts_decorate16([
+  Field16(() => String),
+  _ts_metadata16("design:type", String)
+], Agent.prototype, "name", void 0);
+_ts_decorate16([
+  Field16(() => String),
+  _ts_metadata16("design:type", String)
+], Agent.prototype, "description", void 0);
+Agent = _ts_decorate16([
+  ObjectType4()
+], Agent);
+var AgentsResponse = class {
+  agents;
+};
+__name(AgentsResponse, "AgentsResponse");
+_ts_decorate16([
+  Field16(() => [
+    Agent
+  ]),
+  _ts_metadata16("design:type", Array)
+], AgentsResponse.prototype, "agents", void 0);
+AgentsResponse = _ts_decorate16([
+  ObjectType4()
+], AgentsResponse);
+
+// src/graphql/resolvers/copilot.resolver.ts
+import { CopilotKitError as CopilotKitError2, CopilotKitLowLevelError as CopilotKitLowLevelError2 } from "@copilotkit/shared";
+function _ts_decorate17(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_decorate17, "_ts_decorate");
+function _ts_metadata17(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
+    return Reflect.metadata(k, v);
+}
+__name(_ts_metadata17, "_ts_metadata");
+function _ts_param(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param, "_ts_param");
+var invokeGuardrails = /* @__PURE__ */ __name(async ({ baseUrl, copilotCloudPublicApiKey, data, onResult, onError }) => {
+  var _a;
+  if (data.messages.length && ((_a = data.messages[data.messages.length - 1].textMessage) == null ? void 0 : _a.role) === MessageRole.user) {
+    const messages = data.messages.filter((m) => m.textMessage !== void 0 && (m.textMessage.role === MessageRole.user || m.textMessage.role === MessageRole.assistant)).map((m) => ({
+      role: m.textMessage.role,
+      content: m.textMessage.content
+    }));
+    const lastMessage = messages[messages.length - 1];
+    const restOfMessages = messages.slice(0, -1);
+    const body = {
+      input: lastMessage.content,
+      validTopics: data.cloud.guardrails.inputValidationRules.allowList,
+      invalidTopics: data.cloud.guardrails.inputValidationRules.denyList,
+      messages: restOfMessages
+    };
+    const guardrailsResult = await fetch(`${baseUrl}/guardrails/validate`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "X-CopilotCloud-Public-API-Key": copilotCloudPublicApiKey
+      },
+      body: JSON.stringify(body)
+    });
+    if (guardrailsResult.ok) {
+      const resultJson = await guardrailsResult.json();
+      onResult(resultJson);
+    } else {
+      onError(await guardrailsResult.json());
+    }
+  }
+}, "invokeGuardrails");
+var CopilotResolver = class {
+  async hello() {
+    return "Hello World";
+  }
+  async availableAgents(ctx) {
+    let logger2 = ctx.logger.child({
+      component: "CopilotResolver.availableAgents"
+    });
+    logger2.debug("Processing");
+    const agentsWithEndpoints = [];
+    logger2.debug("Event source created, creating response");
+    return {
+      agents: agentsWithEndpoints.map(({ endpoint, ...agentWithoutEndpoint }) => agentWithoutEndpoint)
+    };
+  }
+  async generateCopilotResponse(ctx, data, properties) {
+    var _a, _b, _c, _d;
+    telemetry_client_default.capture("oss.runtime.copilot_request_created", {
+      "cloud.guardrails.enabled": ((_a = data.cloud) == null ? void 0 : _a.guardrails) !== void 0,
+      requestType: data.metadata.requestType,
+      "cloud.api_key_provided": !!ctx.request.headers.get("x-copilotcloud-public-api-key"),
+      ...ctx.request.headers.get("x-copilotcloud-public-api-key") ? {
+        "cloud.public_api_key": ctx.request.headers.get("x-copilotcloud-public-api-key")
+      } : {},
+      ...ctx._copilotkit.baseUrl ? {
+        "cloud.base_url": ctx._copilotkit.baseUrl
+      } : {
+        "cloud.base_url": "https://api.cloud.copilotkit.ai"
+      }
+    });
+    let logger2 = ctx.logger.child({
+      component: "CopilotResolver.generateCopilotResponse"
+    });
+    logger2.debug({
+      data
+    }, "Generating Copilot response");
+    if (properties) {
+      logger2.debug("Properties provided, merging with context properties");
+      ctx.properties = {
+        ...ctx.properties,
+        ...properties
+      };
+    }
+    const copilotRuntime = ctx._copilotkit.runtime;
+    const serviceAdapter = ctx._copilotkit.serviceAdapter;
+    let copilotCloudPublicApiKey = null;
+    let copilotCloudBaseUrl;
+    const publicApiKeyFromHeaders = ctx.request.headers.get("x-copilotcloud-public-api-key");
+    if (publicApiKeyFromHeaders) {
+      copilotCloudPublicApiKey = publicApiKeyFromHeaders;
+    }
+    if (data.cloud) {
+      logger2 = logger2.child({
+        cloud: true
+      });
+      logger2.debug("Cloud configuration provided, checking for public API key in headers");
+      if (!copilotCloudPublicApiKey) {
+        logger2.error("Public API key not found in headers");
+        throw new GraphQLError("X-CopilotCloud-Public-API-Key header is required");
+      }
+      if (process.env.COPILOT_CLOUD_BASE_URL) {
+        copilotCloudBaseUrl = process.env.COPILOT_CLOUD_BASE_URL;
+      } else if ((_b = ctx._copilotkit.cloud) == null ? void 0 : _b.baseUrl) {
+        copilotCloudBaseUrl = (_c = ctx._copilotkit.cloud) == null ? void 0 : _c.baseUrl;
+      } else {
+        copilotCloudBaseUrl = "https://api.cloud.copilotkit.ai";
+      }
+      logger2 = logger2.child({
+        copilotCloudBaseUrl
+      });
+    }
+    logger2.debug("Setting up subjects");
+    const responseStatus$ = new ReplaySubject2();
+    const interruptStreaming$ = new ReplaySubject2();
+    const guardrailsResult$ = new ReplaySubject2();
+    let outputMessages = [];
+    let resolveOutputMessagesPromise;
+    let rejectOutputMessagesPromise;
+    const outputMessagesPromise = new Promise((resolve, reject) => {
+      resolveOutputMessagesPromise = resolve;
+      rejectOutputMessagesPromise = reject;
+    });
+    if (copilotCloudPublicApiKey) {
+      ctx.properties["copilotCloudPublicApiKey"] = copilotCloudPublicApiKey;
+    }
+    logger2.debug("Processing");
+    let runtimeResponse;
+    const { eventSource, threadId = randomId(), runId, serverSideActions, actionInputsWithoutAgents, extensions } = runtimeResponse;
+    logger2.debug("Event source created, creating response");
+    const eventStream = eventSource.processRuntimeEvents({
+      serverSideActions,
+      guardrailsResult$: ((_d = data.cloud) == null ? void 0 : _d.guardrails) ? guardrailsResult$ : null,
+      actionInputsWithoutAgents: actionInputsWithoutAgents.filter(
+        // TODO-AGENTS: do not exclude ALL server side actions
+        (action) => !serverSideActions.find((serverSideAction) => serverSideAction.name == action.name)
+      ),
+      threadId
+    }).pipe(
+      // shareReplay() ensures that later subscribers will see the whole stream instead of
+      // just the events that were emitted after the subscriber was added.
+      shareReplay(),
+      finalize(() => {
+        logger2.debug("Event stream finalized");
+      })
+    );
+    const response = {
+      threadId,
+      runId,
+      status: firstValueFrom(responseStatus$),
+      extensions,
+      metaEvents: new Repeater(async (push, stop) => {
+        let eventStreamSubscription;
+        eventStreamSubscription = eventStream.subscribe({
+          next: async (event) => {
+            if (event.type != RuntimeEventTypes.MetaEvent) {
+              return;
+            }
+            switch (event.name) {
+              case LangGraphEventTypes.OnInterrupt:
+                push(plainToInstance(LangGraphInterruptEvent, {
+                  // @ts-ignore
+                  type: event.type,
+                  // @ts-ignore
+                  name: RuntimeMetaEventName.LangGraphInterruptEvent,
+                  // @ts-ignore
+                  value: event.value
+                }));
+                break;
+              case RuntimeMetaEventName.LangGraphInterruptEvent:
+                push(plainToInstance(LangGraphInterruptEvent, {
+                  type: event.type,
+                  name: event.name,
+                  value: event.value
+                }));
+                break;
+              case RuntimeMetaEventName.CopilotKitLangGraphInterruptEvent:
+                push(plainToInstance(CopilotKitLangGraphInterruptEvent, {
+                  type: event.type,
+                  name: event.name,
+                  data: {
+                    value: event.data.value,
+                    messages: event.data.messages.map((message) => {
+                      if (message.type === "TextMessage" || "content" in message && "role" in message) {
+                        return plainToInstance(TextMessage, {
+                          id: message.id,
+                          createdAt: /* @__PURE__ */ new Date(),
+                          content: [
+                            message.content
+                          ],
+                          role: message.role,
+                          status: new SuccessMessageStatus()
+                        });
+                      }
+                      if ("arguments" in message) {
+                        return plainToInstance(ActionExecutionMessage, {
+                          name: message.name,
+                          id: message.id,
+                          arguments: [
+                            JSON.stringify(message.arguments)
+                          ],
+                          createdAt: /* @__PURE__ */ new Date(),
+                          status: new SuccessMessageStatus()
+                        });
+                      }
+                      throw new Error("Unknown message in metaEvents copilot resolver");
+                    })
+                  }
+                }));
+                break;
+            }
+          },
+          error: (err) => {
+            var _a2, _b2;
+            if (((_a2 = err == null ? void 0 : err.name) == null ? void 0 : _a2.includes("CopilotKit")) || ((_b2 = err == null ? void 0 : err.extensions) == null ? void 0 : _b2.visibility)) {
+              responseStatus$.next(new UnknownErrorResponse({
+                description: err.message || "Agent error occurred"
+              }));
+            } else {
+              responseStatus$.next(new UnknownErrorResponse({
+                description: `An unknown error has occurred in the event stream`
+              }));
+            }
+            eventStreamSubscription == null ? void 0 : eventStreamSubscription.unsubscribe();
+            stop();
+          },
+          complete: async () => {
+            logger2.debug("Meta events stream completed");
+            responseStatus$.next(new SuccessResponseStatus());
+            eventStreamSubscription == null ? void 0 : eventStreamSubscription.unsubscribe();
+            stop();
+          }
+        });
+      }),
+      messages: new Repeater(async (pushMessage, stopStreamingMessages) => {
+        var _a2;
+        logger2.debug("Messages repeater created");
+        if ((_a2 = data.cloud) == null ? void 0 : _a2.guardrails) {
+          logger2 = logger2.child({
+            guardrails: true
+          });
+          logger2.debug("Guardrails is enabled, validating input");
+          invokeGuardrails({
+            baseUrl: copilotCloudBaseUrl,
+            copilotCloudPublicApiKey,
+            data,
+            onResult: (result) => {
+              logger2.debug({
+                status: result.status
+              }, "Guardrails validation done");
+              guardrailsResult$.next(result);
+              if (result.status === "denied") {
+                responseStatus$.next(new GuardrailsValidationFailureResponse({
+                  guardrailsReason: result.reason
+                }));
+                interruptStreaming$.next({
+                  reason: `Interrupted due to Guardrails validation failure. Reason: ${result.reason}`
+                });
+                outputMessages = [
+                  plainToInstance(TextMessage, {
+                    id: randomId(),
+                    createdAt: /* @__PURE__ */ new Date(),
+                    content: result.reason,
+                    role: MessageRole.assistant
+                  })
+                ];
+                resolveOutputMessagesPromise(outputMessages);
+              }
+            },
+            onError: (err) => {
+              logger2.error({
+                err
+              }, "Error in guardrails validation");
+              responseStatus$.next(new UnknownErrorResponse({
+                description: `An unknown error has occurred in the guardrails validation`
+              }));
+              interruptStreaming$.next({
+                reason: `Interrupted due to unknown error in guardrails validation`
+              });
+              rejectOutputMessagesPromise(err);
+            }
+          });
+        }
+        let eventStreamSubscription;
+        logger2.debug("Event stream created, subscribing to event stream");
+        eventStreamSubscription = eventStream.subscribe({
+          next: async (event) => {
+            switch (event.type) {
+              case RuntimeEventTypes.MetaEvent:
+                break;
+              case RuntimeEventTypes.TextMessageStart:
+                const textMessageContentStream = eventStream.pipe(
+                  // skip until this message start event
+                  skipWhile((e) => e !== event),
+                  // take until the message end event
+                  takeWhile((e) => !(e.type === RuntimeEventTypes.TextMessageEnd && e.messageId == event.messageId)),
+                  // filter out any other message events or message ids
+                  filter((e) => e.type == RuntimeEventTypes.TextMessageContent && e.messageId == event.messageId)
+                );
+                const streamingTextStatus = new Subject();
+                const messageId = event.messageId;
+                pushMessage({
+                  id: messageId,
+                  parentMessageId: event.parentMessageId,
+                  status: firstValueFrom(streamingTextStatus),
+                  createdAt: /* @__PURE__ */ new Date(),
+                  role: MessageRole.assistant,
+                  content: new Repeater(async (pushTextChunk, stopStreamingText) => {
+                    logger2.debug("Text message content repeater created");
+                    const textChunks = [];
+                    let textSubscription;
+                    interruptStreaming$.pipe(shareReplay(), take(1), tap(({ reason, messageId: messageId2 }) => {
+                      logger2.debug({
+                        reason,
+                        messageId: messageId2
+                      }, "Text streaming interrupted");
+                      streamingTextStatus.next(plainToInstance(FailedMessageStatus, {
+                        reason
+                      }));
+                      responseStatus$.next(new MessageStreamInterruptedResponse({
+                        messageId: messageId2
+                      }));
+                      stopStreamingText();
+                      textSubscription == null ? void 0 : textSubscription.unsubscribe();
+                    })).subscribe();
+                    logger2.debug("Subscribing to text message content stream");
+                    textSubscription = textMessageContentStream.subscribe({
+                      next: async (e) => {
+                        if (e.type == RuntimeEventTypes.TextMessageContent) {
+                          await pushTextChunk(e.content);
+                          textChunks.push(e.content);
+                        }
+                      },
+                      error: (err) => {
+                        logger2.error({
+                          err
+                        }, "Error in text message content stream");
+                        interruptStreaming$.next({
+                          reason: "Error streaming message content",
+                          messageId
+                        });
+                        stopStreamingText();
+                        textSubscription == null ? void 0 : textSubscription.unsubscribe();
+                      },
+                      complete: () => {
+                        logger2.debug("Text message content stream completed");
+                        streamingTextStatus.next(new SuccessMessageStatus());
+                        stopStreamingText();
+                        textSubscription == null ? void 0 : textSubscription.unsubscribe();
+                        outputMessages.push(plainToInstance(TextMessage, {
+                          id: messageId,
+                          createdAt: /* @__PURE__ */ new Date(),
+                          content: textChunks.join(""),
+                          role: MessageRole.assistant
+                        }));
+                      }
+                    });
+                  })
+                });
+                break;
+              case RuntimeEventTypes.ActionExecutionStart:
+                logger2.debug("Action execution start event received");
+                const actionExecutionArgumentStream = eventStream.pipe(
+                  skipWhile((e) => e !== event),
+                  // take until the action execution end event
+                  takeWhile((e) => !(e.type === RuntimeEventTypes.ActionExecutionEnd && e.actionExecutionId == event.actionExecutionId)),
+                  // filter out any other action execution events or action execution ids
+                  filter((e) => e.type == RuntimeEventTypes.ActionExecutionArgs && e.actionExecutionId == event.actionExecutionId)
+                );
+                const streamingArgumentsStatus = new Subject();
+                pushMessage({
+                  id: event.actionExecutionId,
+                  parentMessageId: event.parentMessageId,
+                  status: firstValueFrom(streamingArgumentsStatus),
+                  createdAt: /* @__PURE__ */ new Date(),
+                  name: event.actionName,
+                  arguments: new Repeater(async (pushArgumentsChunk, stopStreamingArguments) => {
+                    logger2.debug("Action execution argument stream created");
+                    const argumentChunks = [];
+                    let actionExecutionArgumentSubscription;
+                    actionExecutionArgumentSubscription = actionExecutionArgumentStream.subscribe({
+                      next: async (e) => {
+                        if (e.type == RuntimeEventTypes.ActionExecutionArgs) {
+                          await pushArgumentsChunk(e.args);
+                          argumentChunks.push(e.args);
+                        }
+                      },
+                      error: (err) => {
+                        logger2.error({
+                          err
+                        }, "Error in action execution argument stream");
+                        streamingArgumentsStatus.next(plainToInstance(FailedMessageStatus, {
+                          reason: "An unknown error has occurred in the action execution argument stream"
+                        }));
+                        stopStreamingArguments();
+                        actionExecutionArgumentSubscription == null ? void 0 : actionExecutionArgumentSubscription.unsubscribe();
+                      },
+                      complete: () => {
+                        logger2.debug("Action execution argument stream completed");
+                        streamingArgumentsStatus.next(new SuccessMessageStatus());
+                        stopStreamingArguments();
+                        actionExecutionArgumentSubscription == null ? void 0 : actionExecutionArgumentSubscription.unsubscribe();
+                        outputMessages.push(plainToInstance(ActionExecutionMessage, {
+                          id: event.actionExecutionId,
+                          createdAt: /* @__PURE__ */ new Date(),
+                          name: event.actionName,
+                          arguments: argumentChunks.join("")
+                        }));
+                      }
+                    });
+                  })
+                });
+                break;
+              case RuntimeEventTypes.ActionExecutionResult:
+                logger2.debug({
+                  result: event.result
+                }, "Action execution result event received");
+                pushMessage({
+                  id: "result-" + event.actionExecutionId,
+                  status: new SuccessMessageStatus(),
+                  createdAt: /* @__PURE__ */ new Date(),
+                  actionExecutionId: event.actionExecutionId,
+                  actionName: event.actionName,
+                  result: event.result
+                });
+                outputMessages.push(plainToInstance(ResultMessage, {
+                  id: "result-" + event.actionExecutionId,
+                  createdAt: /* @__PURE__ */ new Date(),
+                  actionExecutionId: event.actionExecutionId,
+                  actionName: event.actionName,
+                  result: event.result
+                }));
+                break;
+              case RuntimeEventTypes.AgentStateMessage:
+                logger2.debug({
+                  event
+                }, "Agent message event received");
+                pushMessage({
+                  id: randomId(),
+                  status: new SuccessMessageStatus(),
+                  threadId: event.threadId,
+                  agentName: event.agentName,
+                  nodeName: event.nodeName,
+                  runId: event.runId,
+                  active: event.active,
+                  state: event.state,
+                  running: event.running,
+                  role: MessageRole.assistant,
+                  createdAt: /* @__PURE__ */ new Date()
+                });
+                outputMessages.push(plainToInstance(AgentStateMessage, {
+                  id: randomId(),
+                  threadId: event.threadId,
+                  agentName: event.agentName,
+                  nodeName: event.nodeName,
+                  runId: event.runId,
+                  active: event.active,
+                  state: event.state,
+                  running: event.running,
+                  role: MessageRole.assistant,
+                  createdAt: /* @__PURE__ */ new Date()
+                }));
+                break;
+            }
+          },
+          error: (err) => {
+            var _a3, _b2, _c2, _d2, _e, _f;
+            if (err instanceof CopilotKitError2 || err instanceof CopilotKitLowLevelError2 || err instanceof Error && err.name && err.name.includes("CopilotKit") || ((_a3 = err == null ? void 0 : err.extensions) == null ? void 0 : _a3.visibility)) {
+              responseStatus$.next(new UnknownErrorResponse({
+                description: err.message || "Agent error occurred",
+                // Include original error information for frontend to extract
+                originalError: {
+                  code: err.code || ((_b2 = err.extensions) == null ? void 0 : _b2.code),
+                  statusCode: err.statusCode || ((_c2 = err.extensions) == null ? void 0 : _c2.statusCode),
+                  severity: err.severity || ((_d2 = err.extensions) == null ? void 0 : _d2.severity),
+                  visibility: err.visibility || ((_e = err.extensions) == null ? void 0 : _e.visibility),
+                  originalErrorType: err.originalErrorType || ((_f = err.extensions) == null ? void 0 : _f.originalErrorType),
+                  extensions: err.extensions
+                }
+              }));
+              eventStreamSubscription == null ? void 0 : eventStreamSubscription.unsubscribe();
+              rejectOutputMessagesPromise(err);
+              stopStreamingMessages();
+              return;
+            }
+            responseStatus$.next(new UnknownErrorResponse({
+              description: `An unknown error has occurred in the event stream`
+            }));
+            eventStreamSubscription == null ? void 0 : eventStreamSubscription.unsubscribe();
+            stopStreamingMessages();
+            rejectOutputMessagesPromise(err);
+          },
+          complete: async () => {
+            var _a3;
+            logger2.debug("Event stream completed");
+            if ((_a3 = data.cloud) == null ? void 0 : _a3.guardrails) {
+              logger2.debug("Guardrails is enabled, waiting for guardrails result");
+              await firstValueFrom(guardrailsResult$);
+            }
+            responseStatus$.next(new SuccessResponseStatus());
+            eventStreamSubscription == null ? void 0 : eventStreamSubscription.unsubscribe();
+            stopStreamingMessages();
+            resolveOutputMessagesPromise(outputMessages);
+          }
+        });
+      })
+    };
+    return response;
+  }
+};
+__name(CopilotResolver, "CopilotResolver");
+_ts_decorate17([
+  Query(() => String),
+  _ts_metadata17("design:type", Function),
+  _ts_metadata17("design:paramtypes", []),
+  _ts_metadata17("design:returntype", Promise)
+], CopilotResolver.prototype, "hello", null);
+_ts_decorate17([
+  Query(() => AgentsResponse),
+  _ts_param(0, Ctx()),
+  _ts_metadata17("design:type", Function),
+  _ts_metadata17("design:paramtypes", [
+    typeof GraphQLContext === "undefined" ? Object : GraphQLContext
+  ]),
+  _ts_metadata17("design:returntype", Promise)
+], CopilotResolver.prototype, "availableAgents", null);
+_ts_decorate17([
+  Mutation(() => CopilotResponse),
+  _ts_param(0, Ctx()),
+  _ts_param(1, Arg("data")),
+  _ts_param(2, Arg("properties", () => GraphQLJSONObject, {
+    nullable: true
+  })),
+  _ts_metadata17("design:type", Function),
+  _ts_metadata17("design:paramtypes", [
+    typeof GraphQLContext === "undefined" ? Object : GraphQLContext,
+    typeof GenerateCopilotResponseInput === "undefined" ? Object : GenerateCopilotResponseInput,
+    typeof CopilotRequestContextProperties === "undefined" ? Object : CopilotRequestContextProperties
+  ]),
+  _ts_metadata17("design:returntype", Promise)
+], CopilotResolver.prototype, "generateCopilotResponse", null);
+CopilotResolver = _ts_decorate17([
+  Resolver(() => CopilotResponse)
+], CopilotResolver);
+
+// src/lib/integrations/shared.ts
+import { useDeferStream } from "@graphql-yoga/plugin-defer-stream";
+
+// src/lib/logger.ts
+import createPinoLogger from "pino";
+import pretty from "pino-pretty";
+function createLogger(options) {
+  const { level, component } = options || {};
+  const stream = pretty({
+    colorize: true
+  });
+  const logger2 = createPinoLogger({
+    level: process.env.LOG_LEVEL || level || "error",
+    redact: {
+      paths: [
+        "pid",
+        "hostname"
+      ],
+      remove: true
+    }
+  }, stream);
+  if (component) {
+    return logger2.child({
+      component
+    });
+  } else {
+    return logger2;
+  }
+}
+__name(createLogger, "createLogger");
+
+// src/graphql/resolvers/state.resolver.ts
+import { Arg as Arg2, Resolver as Resolver2 } from "type-graphql";
+import { Ctx as Ctx2 } from "type-graphql";
+import { Query as Query2 } from "type-graphql";
+
+// src/graphql/types/load-agent-state-response.type.ts
+import { Field as Field17, ObjectType as ObjectType5 } from "type-graphql";
+function _ts_decorate18(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_decorate18, "_ts_decorate");
+function _ts_metadata18(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
+    return Reflect.metadata(k, v);
+}
+__name(_ts_metadata18, "_ts_metadata");
+var LoadAgentStateResponse = class {
+  threadId;
+  threadExists;
+  state;
+  messages;
+};
+__name(LoadAgentStateResponse, "LoadAgentStateResponse");
+_ts_decorate18([
+  Field17(() => String),
+  _ts_metadata18("design:type", String)
+], LoadAgentStateResponse.prototype, "threadId", void 0);
+_ts_decorate18([
+  Field17(() => Boolean),
+  _ts_metadata18("design:type", Boolean)
+], LoadAgentStateResponse.prototype, "threadExists", void 0);
+_ts_decorate18([
+  Field17(() => String),
+  _ts_metadata18("design:type", String)
+], LoadAgentStateResponse.prototype, "state", void 0);
+_ts_decorate18([
+  Field17(() => String),
+  _ts_metadata18("design:type", String)
+], LoadAgentStateResponse.prototype, "messages", void 0);
+LoadAgentStateResponse = _ts_decorate18([
+  ObjectType5()
+], LoadAgentStateResponse);
+
+// src/graphql/inputs/load-agent-state.input.ts
+import { Field as Field18, InputType as InputType13 } from "type-graphql";
+function _ts_decorate19(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_decorate19, "_ts_decorate");
+function _ts_metadata19(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
+    return Reflect.metadata(k, v);
+}
+__name(_ts_metadata19, "_ts_metadata");
+var LoadAgentStateInput = class {
+  threadId;
+  agentName;
+};
+__name(LoadAgentStateInput, "LoadAgentStateInput");
+_ts_decorate19([
+  Field18(() => String),
+  _ts_metadata19("design:type", String)
+], LoadAgentStateInput.prototype, "threadId", void 0);
+_ts_decorate19([
+  Field18(() => String),
+  _ts_metadata19("design:type", String)
+], LoadAgentStateInput.prototype, "agentName", void 0);
+LoadAgentStateInput = _ts_decorate19([
+  InputType13()
+], LoadAgentStateInput);
+
+// src/graphql/resolvers/state.resolver.ts
+import { CopilotKitAgentDiscoveryError } from "@copilotkit/shared";
+function _ts_decorate20(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_decorate20, "_ts_decorate");
+function _ts_metadata20(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
+    return Reflect.metadata(k, v);
+}
+__name(_ts_metadata20, "_ts_metadata");
+function _ts_param2(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param2, "_ts_param");
+var StateResolver = class {
+  async loadAgentState(ctx, data) {
+    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;
+  }
+};
+__name(StateResolver, "StateResolver");
+_ts_decorate20([
+  Query2(() => LoadAgentStateResponse),
+  _ts_param2(0, Ctx2()),
+  _ts_param2(1, Arg2("data")),
+  _ts_metadata20("design:type", Function),
+  _ts_metadata20("design:paramtypes", [
+    typeof GraphQLContext === "undefined" ? Object : GraphQLContext,
+    typeof LoadAgentStateInput === "undefined" ? Object : LoadAgentStateInput
+  ]),
+  _ts_metadata20("design:returntype", Promise)
+], StateResolver.prototype, "loadAgentState", null);
+StateResolver = _ts_decorate20([
+  Resolver2(() => LoadAgentStateResponse)
+], StateResolver);
+
+// src/lib/integrations/shared.ts
+var packageJson2 = __toESM(require_package());
+import { CopilotKitError as CopilotKitError3, CopilotKitErrorCode as CopilotKitErrorCode2 } from "@copilotkit/shared";
+var logger = createLogger();
+var addCustomHeaderPlugin = {
+  onResponse({ response }) {
+    response.headers.set("X-CopilotKit-Runtime-Version", packageJson2.version);
+  }
+};
+async function createContext(initialContext, copilotKitContext, contextLogger, properties = {}) {
+  logger.debug({
+    copilotKitContext
+  }, "Creating GraphQL context");
+  const ctx = {
+    ...initialContext,
+    _copilotkit: {
+      ...copilotKitContext
+    },
+    properties: {
+      ...properties
+    },
+    logger: contextLogger
+  };
+  return ctx;
+}
+__name(createContext, "createContext");
+function buildSchema(options = {}) {
+  logger.debug("Building GraphQL schema...");
+  const schema = buildSchemaSync({
+    resolvers: [
+      CopilotResolver,
+      StateResolver
+    ],
+    emitSchemaFile: options.emitSchemaFile
+  });
+  logger.debug("GraphQL schema built successfully");
+  return schema;
+}
+__name(buildSchema, "buildSchema");
+function getCommonConfig(options) {
+  var _a;
+  const logLevel = process.env.LOG_LEVEL || options.logLevel || "error";
+  const logger2 = createLogger({
+    level: logLevel,
+    component: "getCommonConfig"
+  });
+  const contextLogger = createLogger({
+    level: logLevel
+  });
+  if (options.cloud) {
+    telemetry_client_default.setCloudConfiguration({
+      publicApiKey: options.cloud.publicApiKey,
+      baseUrl: options.cloud.baseUrl
+    });
+  }
+  if ((_a = options.properties) == null ? void 0 : _a._copilotkit) {
+    telemetry_client_default.setGlobalProperties({
+      _copilotkit: {
+        ...options.properties._copilotkit
+      }
+    });
+  }
+  telemetry_client_default.setGlobalProperties({
+    runtime: {
+      serviceAdapter: options.serviceAdapter.constructor.name
+    }
+  });
+  const userErrorCodes = [
+    CopilotKitErrorCode2.AGENT_NOT_FOUND,
+    CopilotKitErrorCode2.API_NOT_FOUND,
+    CopilotKitErrorCode2.REMOTE_ENDPOINT_NOT_FOUND,
+    CopilotKitErrorCode2.CONFIGURATION_ERROR,
+    CopilotKitErrorCode2.MISSING_PUBLIC_API_KEY_ERROR
+  ];
+  return {
+    logging: createLogger({
+      component: "Yoga GraphQL",
+      level: logLevel
+    }),
+    schema: buildSchema(),
+    plugins: [
+      useDeferStream(),
+      addCustomHeaderPlugin
+    ],
+    context: (ctx) => createContext(ctx, options, contextLogger, options.properties),
+    // Suppress logging for user configuration errors
+    maskedErrors: {
+      maskError: (error, message, isDev) => {
+        const originalError = error.originalError || error;
+        const extensions = error.extensions;
+        const errorCode = extensions == null ? void 0 : extensions.code;
+        if (errorCode && userErrorCodes.includes(errorCode)) {
+          console.debug("User configuration error:", error.message);
+          return error;
+        }
+        if (originalError instanceof CopilotKitError3 && userErrorCodes.includes(originalError.code)) {
+          console.debug("User configuration error:", error.message);
+          return error;
+        }
+        console.error("Application error:", error);
+        return error;
+      }
+    }
+  };
+}
+__name(getCommonConfig, "getCommonConfig");
+
+// src/lib/integrations/node-http/index.ts
+import { createCopilotEndpointSingleRouteExpress } from "@copilotkitnext/runtime/express";
+function copilotRuntimeNodeHttpEndpoint(options) {
+  var _a;
+  const commonConfig = getCommonConfig(options);
+  telemetry_client_default.setGlobalProperties({
+    runtime: {
+      framework: "node-http"
+    }
+  });
+  if ((_a = options.properties) == null ? void 0 : _a._copilotkit) {
+    telemetry_client_default.setGlobalProperties({
+      _copilotkit: options.properties._copilotkit
+    });
+  }
+  telemetry_client_default.capture("oss.runtime.instance_created", getRuntimeInstanceTelemetryInfo(options));
+  const logger2 = commonConfig.logging;
+  logger2.debug("Creating Node HTTP endpoint");
+  const serviceAdapter = options.serviceAdapter;
+  options.runtime.handleServiceAdapter(serviceAdapter);
+  return createCopilotEndpointSingleRouteExpress({
+    runtime: options.runtime.instance,
+    basePath: options.baseUrl ?? options.endpoint
+  });
+}
+__name(copilotRuntimeNodeHttpEndpoint, "copilotRuntimeNodeHttpEndpoint");
+
+export {
+  extractParametersFromSchema,
+  convertMCPToolsToActions,
+  generateMcpToolInstructions,
+  LangGraphHttpAgent,
+  CustomEventNames2 as CustomEventNames,
+  LangGraphAgent,
+  CopilotRuntime,
+  copilotKitEndpoint,
+  langGraphPlatformEndpoint,
+  resolveEndpointType,
+  getRuntimeInstanceTelemetryInfo,
+  telemetry_client_default,
+  createLogger,
+  addCustomHeaderPlugin,
+  createContext,
+  buildSchema,
+  getCommonConfig,
+  copilotRuntimeNodeHttpEndpoint
+};
+//# sourceMappingURL=chunk-ZE4SMZZR.mjs.map