agentstack-sdk 0.6.1 → 0.6.2-rc2

package/dist/server.cjs

@@ -0,0 +1,2762 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/server.ts
+var server_exports = {};
+__export(server_exports, {
+  AgentDetailExtensionSpec: () => AgentDetailExtensionSpec,
+  LLMExtensionServer: () => LLMExtensionServer,
+  LLMExtensionSpec: () => LLMExtensionSpec,
+  PLATFORM_SELF_REGISTRATION_EXTENSION_URI: () => PLATFORM_SELF_REGISTRATION_EXTENSION_URI,
+  PlatformSelfRegistrationExtensionSpec: () => PlatformSelfRegistrationExtensionSpec,
+  RunContext: () => RunContext,
+  Server: () => Server,
+  configSchema: () => configSchema,
+  isProductionMode: () => isProductionMode,
+  loadConfig: () => loadConfig
+});
+module.exports = __toCommonJS(server_exports);
+
+// src/client/a2a/extensions/auth/oauth/index.ts
+var import_zod2 = __toESM(require("zod"), 1);
+
+// src/client/a2a/extensions/auth/oauth/schemas.ts
+var import_zod = __toESM(require("zod"), 1);
+var oauthDemandSchema = import_zod.default.object({
+  redirect_uri: import_zod.default.boolean()
+});
+var oauthDemandsSchema = import_zod.default.object({
+  oauth_demands: import_zod.default.record(import_zod.default.string(), oauthDemandSchema)
+});
+var oauthFulfillmentSchema = import_zod.default.object({
+  redirect_uri: import_zod.default.string()
+});
+var oauthFulfillmentsSchema = import_zod.default.object({
+  oauth_fulfillments: import_zod.default.record(import_zod.default.string(), oauthFulfillmentSchema)
+});
+var oauthRequestSchema = import_zod.default.object({
+  authorization_endpoint_url: import_zod.default.string()
+});
+var oauthResponseSchema = import_zod.default.object({
+  redirect_uri: import_zod.default.string()
+});
+var oauthMessageSchema = import_zod.default.object({
+  data: oauthResponseSchema
+});
+
+// src/client/a2a/extensions/auth/secrets/index.ts
+var import_zod4 = __toESM(require("zod"), 1);
+
+// src/client/a2a/extensions/auth/secrets/schemas.ts
+var import_zod3 = __toESM(require("zod"), 1);
+var secretDemandSchema = import_zod3.default.object({
+  name: import_zod3.default.string(),
+  description: import_zod3.default.string().nullish()
+});
+var secretDemandsSchema = import_zod3.default.object({
+  secret_demands: import_zod3.default.record(import_zod3.default.string(), secretDemandSchema)
+});
+var secretFulfillmentSchema = import_zod3.default.object({
+  secret: import_zod3.default.string()
+});
+var secretFulfillmentsSchema = import_zod3.default.object({
+  secret_fulfillments: import_zod3.default.record(import_zod3.default.string(), secretFulfillmentSchema)
+});
+
+// src/client/a2a/extensions/interactions/approval/index.ts
+var import_zod6 = __toESM(require("zod"), 1);
+
+// src/client/a2a/extensions/interactions/approval/schemas.ts
+var import_zod5 = __toESM(require("zod"), 1);
+
+// src/client/a2a/extensions/interactions/approval/types.ts
+var ApprovalDecision = /* @__PURE__ */ ((ApprovalDecision2) => {
+  ApprovalDecision2["Approve"] = "approve";
+  ApprovalDecision2["Reject"] = "reject";
+  return ApprovalDecision2;
+})(ApprovalDecision || {});
+
+// src/client/a2a/extensions/interactions/approval/schemas.ts
+var genericApprovalRequestSchema = import_zod5.default.object({
+  action: import_zod5.default.literal("generic"),
+  title: import_zod5.default.string().nullish().describe("A human-readable title for the action being approved."),
+  description: import_zod5.default.string().nullish().describe("A human-readable description of the action being approved.")
+});
+var toolCallApprovalRequestSchema = import_zod5.default.object({
+  action: import_zod5.default.literal("tool-call"),
+  title: import_zod5.default.string().nullish().describe("A human-readable title of the tool."),
+  description: import_zod5.default.string().nullish().describe("A human-readable description of the tool."),
+  name: import_zod5.default.string().describe("The programmatic name of the tool."),
+  input: import_zod5.default.object().nullish().describe("The input for the tool."),
+  server: import_zod5.default.object({
+    name: import_zod5.default.string().describe("The programmatic name of the server."),
+    title: import_zod5.default.string().nullish().describe("A human-readable title for the server."),
+    version: import_zod5.default.string().describe("The version of the server.")
+  }).nullish().describe("The server executing the tool.")
+});
+var approvalRequestSchema = import_zod5.default.discriminatedUnion("action", [
+  genericApprovalRequestSchema,
+  toolCallApprovalRequestSchema
+]);
+var approvalDecisionSchema = import_zod5.default.enum(ApprovalDecision);
+var approvalResponseSchema = import_zod5.default.object({
+  decision: approvalDecisionSchema
+});
+
+// src/client/a2a/extensions/common/form/schemas.ts
+var import_zod7 = __toESM(require("zod"), 1);
+var baseFieldSchema = import_zod7.default.object({
+  id: import_zod7.default.string().nonempty(),
+  label: import_zod7.default.string().nonempty(),
+  required: import_zod7.default.boolean().nullish(),
+  col_span: import_zod7.default.int().min(1).max(4).nullish()
+});
+var textFieldSchema = baseFieldSchema.extend({
+  type: import_zod7.default.literal("text"),
+  placeholder: import_zod7.default.string().nullish(),
+  default_value: import_zod7.default.string().nullish(),
+  auto_resize: import_zod7.default.boolean().default(true).nullish()
+});
+var dateFieldSchema = baseFieldSchema.extend({
+  type: import_zod7.default.literal("date"),
+  placeholder: import_zod7.default.string().nullish(),
+  default_value: import_zod7.default.string().nullish()
+});
+var fileFieldSchema = baseFieldSchema.extend({
+  type: import_zod7.default.literal("file"),
+  accept: import_zod7.default.array(import_zod7.default.string())
+});
+var selectFieldOptionSchema = import_zod7.default.object({
+  id: import_zod7.default.string().nonempty(),
+  label: import_zod7.default.string().nonempty()
+});
+var singleSelectFieldSchema = baseFieldSchema.extend({
+  type: import_zod7.default.literal("singleselect"),
+  options: import_zod7.default.array(selectFieldOptionSchema).nonempty(),
+  default_value: import_zod7.default.string().nullish()
+});
+var multiSelectFieldSchema = baseFieldSchema.extend({
+  type: import_zod7.default.literal("multiselect"),
+  options: import_zod7.default.array(selectFieldOptionSchema).nonempty(),
+  default_value: import_zod7.default.array(import_zod7.default.string()).nullish()
+});
+var checkboxFieldSchema = baseFieldSchema.extend({
+  type: import_zod7.default.literal("checkbox"),
+  content: import_zod7.default.string(),
+  default_value: import_zod7.default.boolean().nullish()
+});
+var formFieldSchema = import_zod7.default.discriminatedUnion("type", [
+  textFieldSchema,
+  dateFieldSchema,
+  fileFieldSchema,
+  singleSelectFieldSchema,
+  multiSelectFieldSchema,
+  checkboxFieldSchema
+]);
+var textFieldValueSchema = import_zod7.default.object({
+  type: textFieldSchema.shape.type,
+  value: import_zod7.default.string().nullish()
+});
+var dateFieldValueSchema = import_zod7.default.object({
+  type: dateFieldSchema.shape.type,
+  value: import_zod7.default.string().nullish()
+});
+var fileFieldValueSchema = import_zod7.default.object({
+  type: fileFieldSchema.shape.type,
+  value: import_zod7.default.array(
+    import_zod7.default.object({
+      uri: import_zod7.default.string(),
+      name: import_zod7.default.string().nullish(),
+      mime_type: import_zod7.default.string().nullish()
+    })
+  ).nullish()
+});
+var singleSelectFieldValueSchema = import_zod7.default.object({
+  type: singleSelectFieldSchema.shape.type,
+  value: import_zod7.default.string().nullish()
+});
+var multiSelectFieldValueSchema = import_zod7.default.object({
+  type: multiSelectFieldSchema.shape.type,
+  value: import_zod7.default.array(import_zod7.default.string()).nullish()
+});
+var checkboxFieldValueSchema = import_zod7.default.object({
+  type: checkboxFieldSchema.shape.type,
+  value: import_zod7.default.boolean().nullish()
+});
+var formFieldValueSchema = import_zod7.default.discriminatedUnion("type", [
+  textFieldValueSchema,
+  dateFieldValueSchema,
+  fileFieldValueSchema,
+  singleSelectFieldValueSchema,
+  multiSelectFieldValueSchema,
+  checkboxFieldValueSchema
+]);
+var formRenderSchema = import_zod7.default.object({
+  fields: import_zod7.default.array(formFieldSchema).nonempty(),
+  title: import_zod7.default.string().nullish(),
+  description: import_zod7.default.string().nullish(),
+  columns: import_zod7.default.int().min(1).max(4).nullish(),
+  submit_label: import_zod7.default.string().nullish()
+});
+var formValuesSchema = import_zod7.default.record(import_zod7.default.string(), formFieldValueSchema);
+var formResponseSchema = import_zod7.default.object({
+  values: formValuesSchema
+});
+
+// src/client/a2a/extensions/services/embedding/schemas.ts
+var import_zod8 = __toESM(require("zod"), 1);
+var embeddingDemandSchema = import_zod8.default.object({
+  description: import_zod8.default.string().nullish(),
+  suggested: import_zod8.default.array(import_zod8.default.string()).nullish()
+});
+var embeddingDemandsSchema = import_zod8.default.object({
+  embedding_demands: import_zod8.default.record(import_zod8.default.string(), embeddingDemandSchema)
+});
+var embeddingFulfillmentSchema = import_zod8.default.object({
+  identifier: import_zod8.default.string().nullish(),
+  api_base: import_zod8.default.string(),
+  api_key: import_zod8.default.string(),
+  api_model: import_zod8.default.string()
+});
+var embeddingFulfillmentsSchema = import_zod8.default.object({
+  embedding_fulfillments: import_zod8.default.record(import_zod8.default.string(), embeddingFulfillmentSchema)
+});
+
+// src/client/a2a/extensions/services/form/schemas.ts
+var import_zod9 = __toESM(require("zod"), 1);
+var formDemandsSchema = import_zod9.default.object({
+  form_demands: import_zod9.default.object({
+    initial_form: formRenderSchema
+  }).partial()
+});
+var formFulfillmentsSchema = import_zod9.default.object({
+  form_fulfillments: import_zod9.default.record(import_zod9.default.string(), formResponseSchema)
+});
+
+// src/client/a2a/extensions/services/llm/schemas.ts
+var import_zod10 = __toESM(require("zod"), 1);
+var llmDemandSchema = import_zod10.default.object({
+  description: import_zod10.default.string().nullish(),
+  suggested: import_zod10.default.array(import_zod10.default.string()).nullish()
+});
+var llmDemandsSchema = import_zod10.default.object({
+  llm_demands: import_zod10.default.record(import_zod10.default.string(), llmDemandSchema)
+});
+var llmFulfillmentSchema = import_zod10.default.object({
+  identifier: import_zod10.default.string().nullish(),
+  api_base: import_zod10.default.string(),
+  api_key: import_zod10.default.string(),
+  api_model: import_zod10.default.string()
+});
+var llmFulfillmentsSchema = import_zod10.default.object({
+  llm_fulfillments: import_zod10.default.record(import_zod10.default.string(), llmFulfillmentSchema)
+});
+
+// src/client/a2a/extensions/services/mcp/schemas.ts
+var import_zod11 = __toESM(require("zod"), 1);
+
+// src/client/a2a/extensions/services/mcp/types.ts
+var MCPTransportType = /* @__PURE__ */ ((MCPTransportType2) => {
+  MCPTransportType2["StreamableHttp"] = "streamable_http";
+  MCPTransportType2["Stdio"] = "stdio";
+  return MCPTransportType2;
+})(MCPTransportType || {});
+
+// src/client/a2a/extensions/services/mcp/schemas.ts
+var mcpTransportTypeSchema = import_zod11.default.enum(MCPTransportType);
+var mcpDemandSchema = import_zod11.default.object({
+  description: import_zod11.default.string().nullish(),
+  suggested: import_zod11.default.array(import_zod11.default.string()).nullish(),
+  allowed_transports: import_zod11.default.array(mcpTransportTypeSchema).nullish()
+});
+var mcpDemandsSchema = import_zod11.default.object({
+  mcp_demands: import_zod11.default.record(import_zod11.default.string(), mcpDemandSchema)
+});
+var mcpFulfillmentSchema = import_zod11.default.object({
+  transport: import_zod11.default.object({
+    type: mcpTransportTypeSchema,
+    url: import_zod11.default.string(),
+    headers: import_zod11.default.record(import_zod11.default.string(), import_zod11.default.string()).optional()
+  })
+});
+var mcpFulfillmentsSchema = import_zod11.default.object({
+  mcp_fulfillments: import_zod11.default.record(import_zod11.default.string(), mcpFulfillmentSchema)
+});
+
+// src/client/a2a/extensions/services/platform-api/schemas.ts
+var import_zod12 = __toESM(require("zod"), 1);
+var platformApiMetadataSchema = import_zod12.default.object({
+  base_url: import_zod12.default.string().nullish(),
+  auth_token: import_zod12.default.string(),
+  expires_at: import_zod12.default.string().nullish()
+});
+
+// src/client/a2a/extensions/ui/agent-detail/schemas.ts
+var import_zod13 = __toESM(require("zod"), 1);
+
+// src/client/a2a/extensions/ui/agent-detail/types.ts
+var InteractionMode = /* @__PURE__ */ ((InteractionMode2) => {
+  InteractionMode2["SingleTurn"] = "single-turn";
+  InteractionMode2["MultiTurn"] = "multi-turn";
+  return InteractionMode2;
+})(InteractionMode || {});
+
+// src/client/a2a/extensions/ui/agent-detail/schemas.ts
+var interactionModeSchema = import_zod13.default.enum(InteractionMode);
+var agentDetailToolSchema = import_zod13.default.object({
+  name: import_zod13.default.string(),
+  description: import_zod13.default.string()
+});
+var agentDetailContributorSchema = import_zod13.default.object({
+  name: import_zod13.default.string(),
+  email: import_zod13.default.string().nullish(),
+  url: import_zod13.default.string().nullish()
+});
+var agentDetailSchema = import_zod13.default.object({
+  interaction_mode: import_zod13.default.union([interactionModeSchema, import_zod13.default.string()]).nullish(),
+  user_greeting: import_zod13.default.string().nullish(),
+  input_placeholder: import_zod13.default.string().nullish(),
+  tools: import_zod13.default.array(agentDetailToolSchema).nullish(),
+  framework: import_zod13.default.string().nullish(),
+  license: import_zod13.default.string().nullish(),
+  programming_language: import_zod13.default.string().nullish(),
+  homepage_url: import_zod13.default.string().nullish(),
+  source_code_url: import_zod13.default.string().nullish(),
+  container_image_url: import_zod13.default.string().nullish(),
+  author: agentDetailContributorSchema.nullish(),
+  contributors: import_zod13.default.array(agentDetailContributorSchema).nullish()
+});
+
+// src/client/a2a/extensions/ui/canvas/schemas.ts
+var import_zod14 = __toESM(require("zod"), 1);
+var canvasEditRequestSchema = import_zod14.default.object({
+  start_index: import_zod14.default.int(),
+  end_index: import_zod14.default.int(),
+  description: import_zod14.default.string().nullish(),
+  artifact_id: import_zod14.default.string()
+});
+
+// src/client/a2a/extensions/ui/citation/schemas.ts
+var import_zod15 = __toESM(require("zod"), 1);
+var citationSchema = import_zod15.default.object({
+  url: import_zod15.default.string().nullish(),
+  start_index: import_zod15.default.number().nullish(),
+  end_index: import_zod15.default.number().nullish(),
+  title: import_zod15.default.string().nullish(),
+  description: import_zod15.default.string().nullish()
+});
+var citationMetadataSchema = import_zod15.default.object({
+  citations: import_zod15.default.array(citationSchema)
+});
+
+// src/client/a2a/extensions/ui/error/schemas.ts
+var import_zod16 = __toESM(require("zod"), 1);
+var errorSchema = import_zod16.default.object({
+  title: import_zod16.default.string(),
+  message: import_zod16.default.string()
+});
+var errorGroupSchema = import_zod16.default.object({
+  message: import_zod16.default.string(),
+  errors: import_zod16.default.array(errorSchema)
+});
+var errorMetadataSchema = import_zod16.default.object({
+  error: import_zod16.default.union([errorSchema, errorGroupSchema]),
+  context: import_zod16.default.record(import_zod16.default.string(), import_zod16.default.unknown()).nullish(),
+  stack_trace: import_zod16.default.string().nullish()
+});
+
+// src/client/a2a/extensions/ui/settings/schemas.ts
+var import_zod17 = __toESM(require("zod"), 1);
+var settingsCheckboxFieldSchema = import_zod17.default.object({
+  id: import_zod17.default.string().nonempty(),
+  label: import_zod17.default.string().nonempty(),
+  default_value: import_zod17.default.boolean()
+});
+var settingsCheckboxGroupFieldSchema = import_zod17.default.object({
+  id: import_zod17.default.string().nonempty(),
+  type: import_zod17.default.literal("checkbox_group"),
+  fields: import_zod17.default.array(settingsCheckboxFieldSchema)
+});
+var settingsOptionItemSchema = import_zod17.default.object({
+  label: import_zod17.default.string().nonempty(),
+  value: import_zod17.default.string().nonempty()
+});
+var settingsSingleSelectFieldSchema = import_zod17.default.object({
+  type: import_zod17.default.literal("single_select"),
+  id: import_zod17.default.string().nonempty(),
+  label: import_zod17.default.string().nonempty(),
+  options: import_zod17.default.array(settingsOptionItemSchema).nonempty(),
+  default_value: import_zod17.default.string().nonempty()
+});
+var settingsFieldSchema = import_zod17.default.discriminatedUnion("type", [
+  settingsCheckboxGroupFieldSchema,
+  settingsSingleSelectFieldSchema
+]);
+var settingsCheckboxFieldValueSchema = import_zod17.default.object({
+  value: import_zod17.default.boolean()
+});
+var settingsCheckboxGroupFieldValueSchema = import_zod17.default.object({
+  type: import_zod17.default.literal("checkbox_group"),
+  values: import_zod17.default.record(import_zod17.default.string(), settingsCheckboxFieldValueSchema)
+});
+var settingsSingleSelectFieldValueSchema = import_zod17.default.object({
+  type: import_zod17.default.literal("single_select"),
+  value: import_zod17.default.string()
+});
+var settingsFieldValueSchema = import_zod17.default.discriminatedUnion("type", [
+  settingsCheckboxGroupFieldValueSchema,
+  settingsSingleSelectFieldValueSchema
+]);
+var settingsDemandsSchema = import_zod17.default.object({
+  fields: import_zod17.default.array(settingsFieldSchema)
+});
+var settingsValuesSchema = import_zod17.default.record(import_zod17.default.string(), settingsFieldValueSchema);
+var settingsFulfillmentsSchema = import_zod17.default.object({
+  values: settingsValuesSchema
+});
+
+// src/client/a2a/extensions/ui/trajectory/schemas.ts
+var import_zod18 = __toESM(require("zod"), 1);
+var trajectoryMetadataSchema = import_zod18.default.object({
+  title: import_zod18.default.string().nullish(),
+  content: import_zod18.default.string().nullish(),
+  group_id: import_zod18.default.string().nullish()
+});
+
+// src/client/a2a/extensions/services/llm/index.ts
+var LLM_EXTENSION_URI = "https://a2a-extensions.agentstack.beeai.dev/services/llm/v1";
+
+// src/client/a2a/extensions/ui/agent-detail/index.ts
+var import_zod19 = __toESM(require("zod"), 1);
+var AGENT_DETAIL_EXTENSION_URI = "https://a2a-extensions.agentstack.beeai.dev/ui/agent-detail/v1";
+
+// src/client/a2a/extensions/ui/canvas/index.ts
+var import_zod20 = __toESM(require("zod"), 1);
+
+// src/client/a2a/extensions/ui/citation/index.ts
+var import_zod21 = __toESM(require("zod"), 1);
+
+// src/client/a2a/extensions/ui/error/index.ts
+var import_zod22 = __toESM(require("zod"), 1);
+
+// src/client/a2a/extensions/ui/form-request/index.ts
+var import_zod23 = __toESM(require("zod"), 1);
+
+// src/client/a2a/extensions/ui/trajectory/index.ts
+var import_zod24 = __toESM(require("zod"), 1);
+
+// src/experimental/server/a2a/extensions/agent-detail/index.ts
+var AgentDetailExtensionSpec = class {
+  uri = AGENT_DETAIL_EXTENSION_URI;
+  params;
+  constructor(params) {
+    this.params = {
+      ...params,
+      programming_language: params.programming_language ?? "TypeScript"
+    };
+  }
+  toAgentCardExtension() {
+    return {
+      uri: this.uri,
+      required: false,
+      params: this.params
+    };
+  }
+  parseFulfillments() {
+    return void 0;
+  }
+};
+
+// src/experimental/server/a2a/extensions/llm/index.ts
+var LLMExtensionSpec = class {
+  uri = LLM_EXTENSION_URI;
+  params;
+  fulfillmentsSchema = llmFulfillmentsSchema;
+  constructor(params) {
+    this.params = params;
+  }
+  toAgentCardExtension() {
+    return {
+      uri: this.uri,
+      required: true,
+      params: {
+        llm_demands: this.params.demands
+      }
+    };
+  }
+  parseFulfillments(message) {
+    const { metadata } = message;
+    if (!metadata) {
+      return void 0;
+    }
+    const extensionData = metadata[this.uri];
+    if (!extensionData) {
+      return void 0;
+    }
+    const { success, data } = this.fulfillmentsSchema.safeParse(extensionData);
+    if (!success) {
+      return void 0;
+    }
+    return data;
+  }
+};
+var LLMExtensionServer = class {
+  spec;
+  constructor(params) {
+    this.spec = new LLMExtensionSpec(params);
+  }
+  resolveDeps(fulfillments) {
+    return {
+      fulfillments: fulfillments?.llm_fulfillments
+    };
+  }
+};
+
+// src/experimental/server/a2a/extensions/platform-self-registration/index.ts
+var PLATFORM_SELF_REGISTRATION_EXTENSION_URI = "https://a2a-extensions.agentstack.beeai.dev/services/platform-self-registration/v1";
+var PlatformSelfRegistrationExtensionSpec = class {
+  uri = PLATFORM_SELF_REGISTRATION_EXTENSION_URI;
+  params;
+  constructor(params) {
+    this.params = params;
+  }
+  toAgentCardExtension() {
+    return {
+      uri: this.uri,
+      required: false,
+      params: this.params
+    };
+  }
+  parseFulfillments() {
+    return void 0;
+  }
+};
+
+// src/experimental/server/core/config/schemas.ts
+var import_zod25 = __toESM(require("zod"), 1);
+var configSchema = import_zod25.default.object({
+  platformUrl: import_zod25.default.string().default("http://127.0.0.1:8333"),
+  productionMode: import_zod25.default.string().optional().transform((value) => value?.toLowerCase() === "true" || value === "1").default(false)
+});
+
+// src/experimental/server/core/config/index.ts
+function loadConfig() {
+  return configSchema.parse({
+    platformUrl: process.env.PLATFORM_URL,
+    productionMode: process.env.PRODUCTION_MODE
+  });
+}
+function isProductionMode() {
+  return loadConfig().productionMode;
+}
+
+// src/experimental/server/core/context/index.ts
+var RunContext = class {
+  taskId;
+  contextId;
+  task;
+  constructor(taskId, contextId, task) {
+    this.taskId = taskId;
+    this.contextId = contextId;
+    this.task = task;
+  }
+};
+
+// src/experimental/server/core/server/index.ts
+var import_server = require("@a2a-js/sdk/server");
+var import_express = require("@a2a-js/sdk/server/express");
+var import_express2 = __toESM(require("express"), 1);
+
+// src/client/api/configuration/schemas.ts
+var import_zod26 = __toESM(require("zod"), 1);
+var systemConfigurationSchema = import_zod26.default.object({
+  id: import_zod26.default.string(),
+  created_by: import_zod26.default.string(),
+  updated_at: import_zod26.default.string(),
+  default_embedding_model: import_zod26.default.string().nullish(),
+  default_llm_model: import_zod26.default.string().nullish()
+});
+var readSystemConfigurationRequestSchema = import_zod26.default.never();
+var readSystemConfigurationResponseSchema = systemConfigurationSchema;
+var updateSystemConfigurationRequestSchema = import_zod26.default.object({
+  default_embedding_model: import_zod26.default.string().nullish(),
+  default_llm_model: import_zod26.default.string().nullish()
+});
+var updateSystemConfigurationResponseSchema = systemConfigurationSchema;
+
+// src/client/api/configuration/api.ts
+function createConfigurationApi(callApi) {
+  const readSystemConfiguration = () => callApi({
+    method: "GET" /* Get */,
+    path: "/api/v1/configurations/system",
+    schema: readSystemConfigurationResponseSchema
+  });
+  const updateSystemConfiguration = ({ ...body }) => callApi({
+    method: "PUT" /* Put */,
+    path: "/api/v1/configurations/system",
+    schema: updateSystemConfigurationResponseSchema,
+    body
+  });
+  return {
+    readSystemConfiguration,
+    updateSystemConfiguration
+  };
+}
+
+// src/client/api/connectors/schemas.ts
+var import_zod28 = __toESM(require("zod"), 1);
+
+// src/client/api/core/schemas.ts
+var import_zod27 = __toESM(require("zod"), 1);
+var paginationQuerySchema = import_zod27.default.object({
+  limit: import_zod27.default.number().optional(),
+  order: import_zod27.default.string().optional(),
+  order_by: import_zod27.default.string().optional(),
+  page_token: import_zod27.default.string().nullish()
+});
+var paginatedResponseSchema = import_zod27.default.object({
+  items: import_zod27.default.array(import_zod27.default.unknown()),
+  total_count: import_zod27.default.number(),
+  has_more: import_zod27.default.boolean(),
+  next_page_token: import_zod27.default.string().nullable()
+});
+
+// src/client/api/connectors/types.ts
+var ConnectorState = /* @__PURE__ */ ((ConnectorState2) => {
+  ConnectorState2["Created"] = "created";
+  ConnectorState2["AuthRequired"] = "auth_required";
+  ConnectorState2["Connected"] = "connected";
+  ConnectorState2["Disconnected"] = "disconnected";
+  return ConnectorState2;
+})(ConnectorState || {});
+
+// src/client/api/connectors/schemas.ts
+var connectorStateSchema = import_zod28.default.enum(ConnectorState);
+var connectorSchema = import_zod28.default.object({
+  id: import_zod28.default.string(),
+  url: import_zod28.default.string(),
+  state: connectorStateSchema,
+  auth_request: import_zod28.default.object({
+    type: import_zod28.default.literal("code"),
+    authorization_endpoint: import_zod28.default.string()
+  }).nullable(),
+  disconnect_reason: import_zod28.default.string().nullable(),
+  metadata: import_zod28.default.record(import_zod28.default.string(), import_zod28.default.string()).nullable()
+});
+var listConnectorsRequestSchema = import_zod28.default.never();
+var listConnectorsResponseSchema = paginatedResponseSchema.extend({
+  items: import_zod28.default.array(connectorSchema)
+});
+var createConnectorRequestSchema = import_zod28.default.object({
+  match_preset: import_zod28.default.boolean(),
+  url: import_zod28.default.string(),
+  client_id: import_zod28.default.string().nullish(),
+  client_secret: import_zod28.default.string().nullish(),
+  metadata: import_zod28.default.record(import_zod28.default.string(), import_zod28.default.string()).nullish()
+});
+var createConnectorResponseSchema = connectorSchema;
+var readConnectorRequestSchema = import_zod28.default.object({
+  connector_id: import_zod28.default.string()
+});
+var readConnectorResponseSchema = connectorSchema;
+var deleteConnectorRequestSchema = import_zod28.default.object({
+  connector_id: import_zod28.default.string()
+});
+var deleteConnectorResponseSchema = import_zod28.default.null();
+var connectConnectorRequestSchema = import_zod28.default.object({
+  connector_id: import_zod28.default.string(),
+  redirect_url: import_zod28.default.string().nullish()
+});
+var connectConnectorResponseSchema = connectorSchema;
+var disconnectConnectorRequestSchema = import_zod28.default.object({
+  connector_id: import_zod28.default.string()
+});
+var disconnectConnectorResponseSchema = connectorSchema;
+var connectorPresetSchema = import_zod28.default.object({
+  url: import_zod28.default.string(),
+  metadata: import_zod28.default.record(import_zod28.default.string(), import_zod28.default.string()).nullable()
+});
+var listConnectorPresetsRequestSchema = import_zod28.default.never();
+var listConnectorPresetsResponseSchema = paginatedResponseSchema.extend({
+  items: import_zod28.default.array(connectorPresetSchema)
+});
+
+// src/client/api/connectors/api.ts
+function createConnectorsApi(callApi) {
+  const listConnectors = () => callApi({
+    method: "GET" /* Get */,
+    path: "/api/v1/connectors",
+    schema: listConnectorsResponseSchema
+  });
+  const createConnector = ({ ...body }) => callApi({
+    method: "POST" /* Post */,
+    path: "/api/v1/connectors",
+    schema: createConnectorResponseSchema,
+    body
+  });
+  const readConnector = ({ connector_id }) => callApi({
+    method: "GET" /* Get */,
+    path: `/api/v1/connectors/${connector_id}`,
+    schema: readConnectorResponseSchema
+  });
+  const deleteConnector = ({ connector_id }) => callApi({
+    method: "DELETE" /* Delete */,
+    path: `/api/v1/connectors/${connector_id}`,
+    schema: deleteConnectorResponseSchema
+  });
+  const connectConnector = ({ connector_id, ...body }) => callApi({
+    method: "POST" /* Post */,
+    path: `/api/v1/connectors/${connector_id}/connect`,
+    schema: connectConnectorResponseSchema,
+    body
+  });
+  const disconnectConnector = ({ connector_id }) => callApi({
+    method: "POST" /* Post */,
+    path: `/api/v1/connectors/${connector_id}/disconnect`,
+    schema: disconnectConnectorResponseSchema
+  });
+  const listConnectorPresets = () => callApi({
+    method: "GET" /* Get */,
+    path: "/api/v1/connectors/presets",
+    schema: listConnectorPresetsResponseSchema
+  });
+  return {
+    listConnectors,
+    createConnector,
+    readConnector,
+    deleteConnector,
+    connectConnector,
+    disconnectConnector,
+    listConnectorPresets
+  };
+}
+
+// src/client/api/contexts/schemas.ts
+var import_zod31 = __toESM(require("zod"), 1);
+
+// src/client/a2a/protocol/schemas.ts
+var import_zod30 = __toESM(require("zod"), 1);
+
+// src/client/a2a/protocol/utils.ts
+var import_zod29 = __toESM(require("zod"), 1);
+function a2aSchema(schema) {
+  return import_zod29.default.preprocess((value) => normalizeOptionalNulls(schema, value), schema);
+}
+function normalizeOptionalNulls(schema, data) {
+  if (schema instanceof import_zod29.default.ZodOptional) {
+    if (data === null) {
+      return void 0;
+    }
+    return normalizeOptionalNulls(schema.unwrap(), data);
+  }
+  if (schema instanceof import_zod29.default.ZodObject) {
+    if (data === null || typeof data !== "object" || Array.isArray(data)) {
+      return data;
+    }
+    const { shape } = schema;
+    const record = data;
+    return Object.keys(record).reduce((acc, key) => {
+      acc[key] = key in shape ? normalizeOptionalNulls(shape[key], record[key]) : record[key];
+      return acc;
+    }, {});
+  }
+  return data;
+}
+
+// src/client/a2a/protocol/schemas.ts
+var agentInterfaceSchema = a2aSchema(
+  import_zod30.default.object({
+    transport: import_zod30.default.string(),
+    url: import_zod30.default.string()
+  })
+);
+var agentExtensionSchema = a2aSchema(
+  import_zod30.default.object({
+    uri: import_zod30.default.string(),
+    description: import_zod30.default.string().optional(),
+    required: import_zod30.default.boolean().optional(),
+    params: import_zod30.default.record(import_zod30.default.string(), import_zod30.default.unknown()).optional()
+  })
+);
+var agentCapabilitiesSchema = a2aSchema(
+  import_zod30.default.object({
+    extensions: import_zod30.default.array(agentExtensionSchema).optional(),
+    pushNotifications: import_zod30.default.boolean().optional(),
+    stateTransitionHistory: import_zod30.default.boolean().optional(),
+    streaming: import_zod30.default.boolean().optional()
+  })
+);
+var agentProviderSchema = a2aSchema(
+  import_zod30.default.object({
+    url: import_zod30.default.string(),
+    organization: import_zod30.default.string()
+  })
+);
+var agentCardSignatureSchema = a2aSchema(
+  import_zod30.default.object({
+    signature: import_zod30.default.string(),
+    protected: import_zod30.default.string(),
+    header: import_zod30.default.record(import_zod30.default.string(), import_zod30.default.unknown()).optional()
+  })
+);
+var agentSkillSchema = a2aSchema(
+  import_zod30.default.object({
+    id: import_zod30.default.string(),
+    name: import_zod30.default.string(),
+    description: import_zod30.default.string(),
+    tags: import_zod30.default.array(import_zod30.default.string()),
+    inputModes: import_zod30.default.array(import_zod30.default.string()).optional(),
+    outputModes: import_zod30.default.array(import_zod30.default.string()).optional(),
+    examples: import_zod30.default.array(import_zod30.default.string()).optional(),
+    security: import_zod30.default.array(import_zod30.default.record(import_zod30.default.string(), import_zod30.default.array(import_zod30.default.string()))).optional()
+  })
+);
+var authorizationCodeOAuthFlowSchema = a2aSchema(
+  import_zod30.default.object({
+    authorizationUrl: import_zod30.default.string(),
+    tokenUrl: import_zod30.default.string(),
+    scopes: import_zod30.default.record(import_zod30.default.string(), import_zod30.default.string()),
+    refreshUrl: import_zod30.default.string().optional()
+  })
+);
+var clientCredentialsOAuthFlowSchema = a2aSchema(
+  import_zod30.default.object({
+    tokenUrl: import_zod30.default.string(),
+    scopes: import_zod30.default.record(import_zod30.default.string(), import_zod30.default.string()),
+    refreshUrl: import_zod30.default.string().optional()
+  })
+);
+var implicitOAuthFlowSchema = a2aSchema(
+  import_zod30.default.object({
+    authorizationUrl: import_zod30.default.string(),
+    scopes: import_zod30.default.record(import_zod30.default.string(), import_zod30.default.string()),
+    refreshUrl: import_zod30.default.string().optional()
+  })
+);
+var passwordOAuthFlowSchema = a2aSchema(
+  import_zod30.default.object({
+    tokenUrl: import_zod30.default.string(),
+    scopes: import_zod30.default.record(import_zod30.default.string(), import_zod30.default.string()),
+    refreshUrl: import_zod30.default.string().optional()
+  })
+);
+var oauthFlowsSchema = a2aSchema(
+  import_zod30.default.object({
+    authorizationCode: authorizationCodeOAuthFlowSchema.optional(),
+    clientCredentials: clientCredentialsOAuthFlowSchema.optional(),
+    implicit: implicitOAuthFlowSchema.optional(),
+    password: passwordOAuthFlowSchema.optional()
+  })
+);
+var apiKeySecuritySchemeSchema = a2aSchema(
+  import_zod30.default.object({
+    type: import_zod30.default.literal("apiKey"),
+    name: import_zod30.default.string(),
+    in: import_zod30.default.literal(["cookie", "header", "query"]),
+    description: import_zod30.default.string().optional()
+  })
+);
+var httpAuthSecuritySchemeSchema = a2aSchema(
+  import_zod30.default.object({
+    type: import_zod30.default.literal("http"),
+    scheme: import_zod30.default.string(),
+    description: import_zod30.default.string().optional(),
+    bearerFormat: import_zod30.default.string().optional()
+  })
+);
+var oauth2SecuritySchemeSchema = a2aSchema(
+  import_zod30.default.object({
+    type: import_zod30.default.literal("oauth2"),
+    flows: oauthFlowsSchema,
+    description: import_zod30.default.string().optional(),
+    oauth2MetadataUrl: import_zod30.default.string().optional()
+  })
+);
+var openIdConnectSecuritySchemeSchema = a2aSchema(
+  import_zod30.default.object({
+    type: import_zod30.default.literal("openIdConnect"),
+    openIdConnectUrl: import_zod30.default.string(),
+    description: import_zod30.default.string().optional()
+  })
+);
+var mutualTlsSecuritySchemeSchema = a2aSchema(
+  import_zod30.default.object({
+    type: import_zod30.default.literal("mutualTLS"),
+    description: import_zod30.default.string().optional()
+  })
+);
+var securitySchemeSchema = a2aSchema(
+  import_zod30.default.union([
+    apiKeySecuritySchemeSchema,
+    httpAuthSecuritySchemeSchema,
+    oauth2SecuritySchemeSchema,
+    openIdConnectSecuritySchemeSchema,
+    mutualTlsSecuritySchemeSchema
+  ])
+);
+var agentCardSchema = a2aSchema(
+  import_zod30.default.object({
+    url: import_zod30.default.string(),
+    name: import_zod30.default.string(),
+    description: import_zod30.default.string(),
+    version: import_zod30.default.string(),
+    protocolVersion: import_zod30.default.string(),
+    capabilities: agentCapabilitiesSchema,
+    defaultInputModes: import_zod30.default.array(import_zod30.default.string()),
+    defaultOutputModes: import_zod30.default.array(import_zod30.default.string()),
+    skills: import_zod30.default.array(agentSkillSchema),
+    iconUrl: import_zod30.default.string().optional(),
+    documentationUrl: import_zod30.default.string().optional(),
+    preferredTransport: import_zod30.default.string().optional(),
+    supportsAuthenticatedExtendedCard: import_zod30.default.boolean().optional(),
+    additionalInterfaces: import_zod30.default.array(agentInterfaceSchema).optional(),
+    provider: agentProviderSchema.optional(),
+    signatures: import_zod30.default.array(agentCardSignatureSchema).optional(),
+    security: import_zod30.default.array(import_zod30.default.record(import_zod30.default.string(), import_zod30.default.array(import_zod30.default.string()))).optional(),
+    securitySchemes: import_zod30.default.record(import_zod30.default.string(), securitySchemeSchema).optional()
+  })
+);
+var fileWithBytesSchema = a2aSchema(
+  import_zod30.default.object({
+    bytes: import_zod30.default.string(),
+    mimeType: import_zod30.default.string().optional(),
+    name: import_zod30.default.string().optional()
+  })
+);
+var fileWithUriSchema = a2aSchema(
+  import_zod30.default.object({
+    uri: import_zod30.default.string(),
+    mimeType: import_zod30.default.string().optional(),
+    name: import_zod30.default.string().optional()
+  })
+);
+var textPartSchema = a2aSchema(
+  import_zod30.default.object({
+    kind: import_zod30.default.literal("text"),
+    text: import_zod30.default.string(),
+    metadata: import_zod30.default.record(import_zod30.default.string(), import_zod30.default.unknown()).optional()
+  })
+);
+var filePartSchema = a2aSchema(
+  import_zod30.default.object({
+    kind: import_zod30.default.literal("file"),
+    file: import_zod30.default.union([fileWithBytesSchema, fileWithUriSchema]),
+    metadata: import_zod30.default.record(import_zod30.default.string(), import_zod30.default.unknown()).optional()
+  })
+);
+var dataPartSchema = a2aSchema(
+  import_zod30.default.object({
+    kind: import_zod30.default.literal("data"),
+    data: import_zod30.default.record(import_zod30.default.string(), import_zod30.default.unknown()),
+    metadata: import_zod30.default.record(import_zod30.default.string(), import_zod30.default.unknown()).optional()
+  })
+);
+var partSchema = a2aSchema(import_zod30.default.union([textPartSchema, filePartSchema, dataPartSchema]));
+var artifactSchema = a2aSchema(
+  import_zod30.default.object({
+    artifactId: import_zod30.default.string(),
+    parts: import_zod30.default.array(partSchema),
+    description: import_zod30.default.string().optional(),
+    extensions: import_zod30.default.array(import_zod30.default.string()).optional(),
+    metadata: import_zod30.default.record(import_zod30.default.string(), import_zod30.default.unknown()).optional(),
+    name: import_zod30.default.string().optional()
+  })
+);
+var messageSchema = a2aSchema(
+  import_zod30.default.object({
+    kind: import_zod30.default.literal("message"),
+    messageId: import_zod30.default.string(),
+    parts: import_zod30.default.array(partSchema),
+    role: import_zod30.default.literal(["agent", "user"]),
+    contextId: import_zod30.default.string().optional(),
+    extensions: import_zod30.default.array(import_zod30.default.string()).optional(),
+    metadata: import_zod30.default.record(import_zod30.default.string(), import_zod30.default.unknown()).optional(),
+    referenceTaskIds: import_zod30.default.array(import_zod30.default.string()).optional(),
+    taskId: import_zod30.default.string().optional()
+  })
+);
+var taskStatusSchema = a2aSchema(
+  import_zod30.default.object({
+    state: import_zod30.default.literal([
+      "submitted",
+      "working",
+      "input-required",
+      "completed",
+      "canceled",
+      "failed",
+      "rejected",
+      "auth-required",
+      "unknown"
+    ]),
+    message: messageSchema.optional(),
+    timestamp: import_zod30.default.string().optional()
+  })
+);
+var taskStatusUpdateEventSchema = a2aSchema(
+  import_zod30.default.object({
+    kind: import_zod30.default.literal("status-update"),
+    taskId: import_zod30.default.string(),
+    contextId: import_zod30.default.string(),
+    status: taskStatusSchema,
+    final: import_zod30.default.boolean(),
+    metadata: import_zod30.default.record(import_zod30.default.string(), import_zod30.default.unknown()).optional()
+  })
+);
+var taskSchema = a2aSchema(
+  import_zod30.default.object({
+    kind: import_zod30.default.literal("task"),
+    id: import_zod30.default.string(),
+    contextId: import_zod30.default.string(),
+    status: taskStatusSchema,
+    artifacts: import_zod30.default.array(artifactSchema).optional(),
+    history: import_zod30.default.array(messageSchema).optional(),
+    metadata: import_zod30.default.record(import_zod30.default.string(), import_zod30.default.unknown()).optional()
+  })
+);
+var taskArtifactUpdateEventSchema = a2aSchema(
+  import_zod30.default.object({
+    kind: import_zod30.default.literal("artifact-update"),
+    taskId: import_zod30.default.string(),
+    contextId: import_zod30.default.string(),
+    artifact: artifactSchema,
+    append: import_zod30.default.boolean().optional(),
+    lastChunk: import_zod30.default.boolean().optional(),
+    metadata: import_zod30.default.record(import_zod30.default.string(), import_zod30.default.unknown()).optional()
+  })
+);
+var errorBaseSchema = import_zod30.default.object({
+  message: import_zod30.default.string(),
+  data: import_zod30.default.record(import_zod30.default.string(), import_zod30.default.unknown()).optional()
+});
+var jsonRpcErrorSchema = a2aSchema(
+  errorBaseSchema.extend({
+    code: import_zod30.default.number()
+  })
+);
+var jsonParseErrorSchema = a2aSchema(
+  errorBaseSchema.extend({
+    code: import_zod30.default.literal(-32700)
+  })
+);
+var invalidRequestErrorSchema = a2aSchema(
+  errorBaseSchema.extend({
+    code: import_zod30.default.literal(-32600)
+  })
+);
+var methodNotFoundErrorSchema = a2aSchema(
+  errorBaseSchema.extend({
+    code: import_zod30.default.literal(-32601)
+  })
+);
+var invalidParamsErrorSchema = a2aSchema(
+  errorBaseSchema.extend({
+    code: import_zod30.default.literal(-32602)
+  })
+);
+var internalErrorSchema = a2aSchema(
+  errorBaseSchema.extend({
+    code: import_zod30.default.literal(-32603)
+  })
+);
+var taskNotFoundErrorSchema = a2aSchema(
+  errorBaseSchema.extend({
+    code: import_zod30.default.literal(-32001)
+  })
+);
+var taskNotCancelableErrorSchema = a2aSchema(
+  errorBaseSchema.extend({
+    code: import_zod30.default.literal(-32002)
+  })
+);
+var pushNotificationNotSupportedErrorSchema = a2aSchema(
+  errorBaseSchema.extend({
+    code: import_zod30.default.literal(-32003)
+  })
+);
+var unsupportedOperationErrorSchema = a2aSchema(
+  errorBaseSchema.extend({
+    code: import_zod30.default.literal(-32004)
+  })
+);
+var contentTypeNotSupportedErrorSchema = a2aSchema(
+  errorBaseSchema.extend({
+    code: import_zod30.default.literal(-32005)
+  })
+);
+var invalidAgentResponseErrorSchema = a2aSchema(
+  errorBaseSchema.extend({
+    code: import_zod30.default.literal(-32006)
+  })
+);
+var authenticatedExtendedCardNotConfiguredErrorSchema = a2aSchema(
+  errorBaseSchema.extend({
+    code: import_zod30.default.literal(-32007)
+  })
+);
+var jsonRpcErrorResponseSchema = a2aSchema(
+  import_zod30.default.object({
+    jsonrpc: import_zod30.default.literal("2.0"),
+    id: import_zod30.default.union([import_zod30.default.string(), import_zod30.default.number()]).nullable(),
+    error: import_zod30.default.union([
+      jsonRpcErrorSchema,
+      jsonParseErrorSchema,
+      invalidRequestErrorSchema,
+      methodNotFoundErrorSchema,
+      invalidParamsErrorSchema,
+      internalErrorSchema,
+      taskNotFoundErrorSchema,
+      taskNotCancelableErrorSchema,
+      pushNotificationNotSupportedErrorSchema,
+      unsupportedOperationErrorSchema,
+      contentTypeNotSupportedErrorSchema,
+      invalidAgentResponseErrorSchema,
+      authenticatedExtendedCardNotConfiguredErrorSchema
+    ])
+  })
+);
+var getTaskSuccessResponseSchema = a2aSchema(
+  import_zod30.default.object({
+    jsonrpc: import_zod30.default.literal("2.0"),
+    id: import_zod30.default.union([import_zod30.default.string(), import_zod30.default.number()]).nullable(),
+    result: taskSchema
+  })
+);
+var getTaskResponseSchema = a2aSchema(import_zod30.default.union([jsonRpcErrorResponseSchema, getTaskSuccessResponseSchema]));
+
+// src/client/api/contexts/types.ts
+var ContextHistoryKind = /* @__PURE__ */ ((ContextHistoryKind2) => {
+  ContextHistoryKind2["Artifact"] = "artifact";
+  ContextHistoryKind2["Message"] = "message";
+  return ContextHistoryKind2;
+})(ContextHistoryKind || {});
+
+// src/client/api/contexts/schemas.ts
+var contextSchema = import_zod31.default.object({
+  id: import_zod31.default.string(),
+  created_at: import_zod31.default.string(),
+  updated_at: import_zod31.default.string(),
+  last_active_at: import_zod31.default.string(),
+  created_by: import_zod31.default.string(),
+  provider_id: import_zod31.default.string().nullable(),
+  metadata: import_zod31.default.record(import_zod31.default.string(), import_zod31.default.unknown()).nullable()
+});
+var listContextsRequestSchema = import_zod31.default.object({
+  query: paginationQuerySchema.extend({
+    provider_id: import_zod31.default.string().nullish(),
+    include_empty: import_zod31.default.boolean().optional()
+  }).optional()
+});
+var listContextsResponseSchema = paginatedResponseSchema.extend({
+  items: import_zod31.default.array(contextSchema)
+});
+var createContextRequestSchema = import_zod31.default.object({
+  provider_id: import_zod31.default.string().nullish(),
+  metadata: import_zod31.default.record(import_zod31.default.string(), import_zod31.default.string()).nullish()
+});
+var createContextResponseSchema = contextSchema;
+var readContextRequestSchema = import_zod31.default.object({
+  context_id: import_zod31.default.string()
+});
+var readContextResponseSchema = contextSchema;
+var updateContextRequestSchema = import_zod31.default.object({
+  context_id: import_zod31.default.string(),
+  metadata: import_zod31.default.record(import_zod31.default.string(), import_zod31.default.string()).nullish()
+});
+var updateContextResponseSchema = contextSchema;
+var deleteContextRequestSchema = import_zod31.default.object({
+  context_id: import_zod31.default.string()
+});
+var deleteContextResponseSchema = import_zod31.default.null();
+var contextHistoryKind = import_zod31.default.enum(ContextHistoryKind);
+var contextHistorySchema = import_zod31.default.object({
+  id: import_zod31.default.string(),
+  context_id: import_zod31.default.string(),
+  created_at: import_zod31.default.string(),
+  kind: contextHistoryKind,
+  data: import_zod31.default.union([artifactSchema, messageSchema])
+});
+var listContextHistoryRequestSchema = import_zod31.default.object({
+  context_id: import_zod31.default.string(),
+  query: paginationQuerySchema.optional()
+});
+var listContextHistoryResponseSchema = paginatedResponseSchema.extend({
+  items: import_zod31.default.array(contextHistorySchema)
+});
+var createContextHistoryRequestSchema = import_zod31.default.object({
+  context_id: import_zod31.default.string(),
+  data: import_zod31.default.union([artifactSchema, messageSchema])
+});
+var createContextHistoryResponseSchema = import_zod31.default.null();
+var patchContextMetadataRequestSchema = import_zod31.default.object({
+  context_id: import_zod31.default.string(),
+  metadata: import_zod31.default.record(import_zod31.default.string(), import_zod31.default.union([import_zod31.default.string(), import_zod31.default.null()]))
+});
+var patchContextMetadataResponseSchema = contextSchema;
+var contextTokenSchema = import_zod31.default.object({
+  token: import_zod31.default.string(),
+  expires_at: import_zod31.default.string().nullable()
+});
+var resourceIdPermissionSchema = import_zod31.default.object({
+  id: import_zod31.default.string()
+});
+var contextPermissionsGrantSchema = import_zod31.default.object({
+  files: import_zod31.default.array(import_zod31.default.literal(["read", "write", "extract", "*"])).optional(),
+  vector_stores: import_zod31.default.array(import_zod31.default.literal(["read", "write", "*"])).optional(),
+  context_data: import_zod31.default.array(import_zod31.default.literal(["read", "write", "*"])).optional()
+});
+var globalPermissionsGrantSchema = contextPermissionsGrantSchema.extend({
+  feedback: import_zod31.default.array(import_zod31.default.literal("write")).optional(),
+  llm: import_zod31.default.array(import_zod31.default.union([import_zod31.default.literal("*"), resourceIdPermissionSchema])).optional(),
+  embeddings: import_zod31.default.array(import_zod31.default.union([import_zod31.default.literal("*"), resourceIdPermissionSchema])).optional(),
+  model_providers: import_zod31.default.array(import_zod31.default.literal(["read", "write", "*"])).optional(),
+  a2a_proxy: import_zod31.default.array(import_zod31.default.union([import_zod31.default.literal("*"), import_zod31.default.string()])).optional(),
+  providers: import_zod31.default.array(import_zod31.default.literal(["read", "write", "*"])).optional(),
+  provider_variables: import_zod31.default.array(import_zod31.default.literal(["read", "write", "*"])).optional(),
+  contexts: import_zod31.default.array(import_zod31.default.literal(["read", "write", "*"])).optional(),
+  connectors: import_zod31.default.array(import_zod31.default.literal(["read", "write", "proxy", "*"])).optional()
+}).superRefine((val, ctx) => {
+  if (!val.a2a_proxy) return;
+  if (val.a2a_proxy.length === 0) {
+    ctx.addIssue({
+      code: import_zod31.default.ZodIssueCode.custom,
+      message: "a2a_proxy cannot be empty array",
+      path: ["a2a_proxy"]
+    });
+    return;
+  }
+  const hasWildcard = val.a2a_proxy.includes("*");
+  const hasOthers = val.a2a_proxy.some((v) => v !== "*");
+  if (hasWildcard && hasOthers) {
+    ctx.addIssue({
+      code: import_zod31.default.ZodIssueCode.custom,
+      message: "a2a_proxy cannot mix '*' with specific providers",
+      path: ["a2a_proxy"]
+    });
+  }
+});
+var createContextTokenRequestSchema = import_zod31.default.object({
+  context_id: import_zod31.default.string(),
+  grant_context_permissions: contextPermissionsGrantSchema.optional(),
+  grant_global_permissions: globalPermissionsGrantSchema.optional()
+});
+var createContextTokenResponseSchema = contextTokenSchema;
+
+// src/client/api/contexts/api.ts
+function createContextsApi(callApi) {
+  const listContexts = ({ query }) => callApi({
+    method: "GET" /* Get */,
+    path: "/api/v1/contexts",
+    schema: listContextsResponseSchema,
+    query
+  });
+  const createContext = ({ ...body }) => callApi({
+    method: "POST" /* Post */,
+    path: "/api/v1/contexts",
+    schema: createContextResponseSchema,
+    body
+  });
+  const readContext = ({ context_id }) => callApi({
+    method: "GET" /* Get */,
+    path: `/api/v1/contexts/${context_id}`,
+    schema: readContextResponseSchema
+  });
+  const updateContext = ({ context_id, ...body }) => callApi({
+    method: "PUT" /* Put */,
+    path: `/api/v1/contexts/${context_id}`,
+    schema: updateContextResponseSchema,
+    body
+  });
+  const deleteContext = ({ context_id }) => callApi({
+    method: "DELETE" /* Delete */,
+    path: `/api/v1/contexts/${context_id}`,
+    schema: deleteContextResponseSchema
+  });
+  const listContextHistory = ({ context_id, query }) => callApi({
+    method: "GET" /* Get */,
+    path: `/api/v1/contexts/${context_id}/history`,
+    schema: listContextHistoryResponseSchema,
+    query
+  });
+  const createContextHistory = ({ context_id, ...body }) => callApi({
+    method: "POST" /* Post */,
+    path: `/api/v1/contexts/${context_id}/history`,
+    schema: createContextHistoryResponseSchema,
+    body
+  });
+  const patchContextMetadata = ({ context_id, ...body }) => callApi({
+    method: "PATCH" /* Patch */,
+    path: `/api/v1/contexts/${context_id}/metadata`,
+    schema: patchContextMetadataResponseSchema,
+    body
+  });
+  const createContextToken = ({ context_id, ...body }) => callApi({
+    method: "POST" /* Post */,
+    path: `/api/v1/contexts/${context_id}/token`,
+    schema: createContextTokenResponseSchema,
+    body
+  });
+  return {
+    listContexts,
+    createContext,
+    readContext,
+    updateContext,
+    deleteContext,
+    listContextHistory,
+    createContextHistory,
+    patchContextMetadata,
+    createContextToken
+  };
+}
+
+// src/client/api/files/schemas.ts
+var import_zod32 = __toESM(require("zod"), 1);
+
+// src/client/api/files/types.ts
+var FileType = /* @__PURE__ */ ((FileType2) => {
+  FileType2["UserUpload"] = "user_upload";
+  FileType2["ExtractedText"] = "extracted_text";
+  return FileType2;
+})(FileType || {});
+
+// src/client/api/files/schemas.ts
+var fileTypeSchema = import_zod32.default.enum(FileType);
+var fileSchema = import_zod32.default.object({
+  id: import_zod32.default.string(),
+  filename: import_zod32.default.string(),
+  content_type: import_zod32.default.string(),
+  file_type: fileTypeSchema,
+  created_by: import_zod32.default.string(),
+  created_at: import_zod32.default.string(),
+  context_id: import_zod32.default.string().nullish(),
+  file_size_bytes: import_zod32.default.number().nullish(),
+  parent_file_id: import_zod32.default.string().nullish()
+});
+var createFileRequestSchema = import_zod32.default.object({
+  context_id: import_zod32.default.string().nullable(),
+  file: import_zod32.default.union([
+    import_zod32.default.file(),
+    import_zod32.default.object({
+      blob: import_zod32.default.instanceof(Blob),
+      filename: import_zod32.default.string()
+    })
+  ])
+});
+var createFileResponseSchema = fileSchema;
+var readFileRequestSchema = import_zod32.default.object({
+  context_id: import_zod32.default.string().nullable(),
+  file_id: import_zod32.default.string()
+});
+var readFileResponseSchema = fileSchema;
+var deleteFileRequestSchema = import_zod32.default.object({
+  context_id: import_zod32.default.string().nullable(),
+  file_id: import_zod32.default.string()
+});
+var deleteFileResponseSchema = import_zod32.default.null();
+var readFileContentRequestSchema = import_zod32.default.object({
+  context_id: import_zod32.default.string().nullable(),
+  file_id: import_zod32.default.string()
+});
+var readFileContentResponseSchema = import_zod32.default.unknown();
+
+// src/client/api/files/api.ts
+function createFilesApi(callApi) {
+  const createFile = ({ context_id, file }) => {
+    const body = new FormData();
+    if (file instanceof File) {
+      body.append("file", file);
+    } else {
+      body.append("file", file.blob, file.filename);
+    }
+    return callApi({
+      method: "POST" /* Post */,
+      path: "/api/v1/files",
+      schema: createFileResponseSchema,
+      query: { context_id },
+      body
+    });
+  };
+  const readFile = ({ context_id, file_id }) => callApi({
+    method: "GET" /* Get */,
+    path: `/api/v1/files/${file_id}`,
+    schema: readFileResponseSchema,
+    query: { context_id }
+  });
+  const deleteFile = ({ context_id, file_id }) => callApi({
+    method: "DELETE" /* Delete */,
+    path: `/api/v1/files/${file_id}`,
+    schema: deleteFileResponseSchema,
+    query: { context_id }
+  });
+  const readFileContent = ({ context_id, file_id }) => callApi({
+    method: "GET" /* Get */,
+    path: `/api/v1/files/${file_id}/content`,
+    schema: readFileContentResponseSchema,
+    query: { context_id }
+  });
+  return {
+    createFile,
+    readFile,
+    deleteFile,
+    readFileContent
+  };
+}
+
+// src/client/api/model-providers/schemas.ts
+var import_zod33 = __toESM(require("zod"), 1);
+
+// src/client/api/model-providers/types.ts
+var ModelCapability = /* @__PURE__ */ ((ModelCapability2) => {
+  ModelCapability2["Llm"] = "llm";
+  ModelCapability2["Embedding"] = "embedding";
+  return ModelCapability2;
+})(ModelCapability || {});
+var ModelProviderType = /* @__PURE__ */ ((ModelProviderType2) => {
+  ModelProviderType2["Anthropic"] = "anthropic";
+  ModelProviderType2["Cerebras"] = "cerebras";
+  ModelProviderType2["Chutes"] = "chutes";
+  ModelProviderType2["Cohere"] = "cohere";
+  ModelProviderType2["DeepSeek"] = "deepseek";
+  ModelProviderType2["Gemini"] = "gemini";
+  ModelProviderType2["GitHub"] = "github";
+  ModelProviderType2["Groq"] = "groq";
+  ModelProviderType2["Watsonx"] = "watsonx";
+  ModelProviderType2["Jan"] = "jan";
+  ModelProviderType2["Mistral"] = "mistral";
+  ModelProviderType2["Moonshot"] = "moonshot";
+  ModelProviderType2["Nvidia"] = "nvidia";
+  ModelProviderType2["Ollama"] = "ollama";
+  ModelProviderType2["OpenAI"] = "openai";
+  ModelProviderType2["OpenRouter"] = "openrouter";
+  ModelProviderType2["Perplexity"] = "perplexity";
+  ModelProviderType2["Together"] = "together";
+  ModelProviderType2["Voyage"] = "voyage";
+  ModelProviderType2["Rits"] = "rits";
+  ModelProviderType2["Other"] = "other";
+  return ModelProviderType2;
+})(ModelProviderType || {});
+
+// src/client/api/model-providers/schemas.ts
+var modelCapabilitySchema = import_zod33.default.enum(ModelCapability);
+var modelProviderTypeSchema = import_zod33.default.enum(ModelProviderType);
+var modelProviderSchema = import_zod33.default.object({
+  id: import_zod33.default.string(),
+  base_url: import_zod33.default.string(),
+  created_at: import_zod33.default.string(),
+  capabilities: import_zod33.default.array(modelCapabilitySchema),
+  name: import_zod33.default.string().nullish(),
+  description: import_zod33.default.string().nullish(),
+  type: modelProviderTypeSchema
+});
+var listModelProvidersRequestSchema = import_zod33.default.never();
+var listModelProvidersResponseSchema = paginatedResponseSchema.extend({
+  items: import_zod33.default.array(modelProviderSchema)
+});
+var createModelProviderRequestSchema = import_zod33.default.object({
+  api_key: import_zod33.default.string(),
+  base_url: import_zod33.default.string(),
+  type: modelProviderTypeSchema,
+  name: import_zod33.default.string().nullish(),
+  description: import_zod33.default.string().nullish(),
+  watsonx_project_id: import_zod33.default.string().nullish(),
+  watsonx_space_id: import_zod33.default.string().nullish()
+});
+var createModelProviderResponseSchema = modelProviderSchema;
+var readModelProviderRequestSchema = import_zod33.default.object({
+  model_provider_id: import_zod33.default.string()
+});
+var readModelProviderResponseSchema = modelProviderSchema;
+var deleteModelProviderRequestSchema = import_zod33.default.object({
+  model_provider_id: import_zod33.default.string()
+});
+var deleteModelProviderResponseSchema = import_zod33.default.null();
+var matchModelProvidersRequestSchema = import_zod33.default.object({
+  suggested_models: import_zod33.default.array(import_zod33.default.string()).nullable(),
+  capability: modelCapabilitySchema,
+  score_cutoff: import_zod33.default.number()
+});
+var matchModelProvidersResponseSchema = paginatedResponseSchema.extend({
+  items: import_zod33.default.array(
+    import_zod33.default.object({
+      model_id: import_zod33.default.string(),
+      score: import_zod33.default.number()
+    })
+  )
+});
+
+// src/client/api/model-providers/api.ts
+function createModelProvidersApi(callApi) {
+  const listModelProviders = () => callApi({
+    method: "GET" /* Get */,
+    path: "/api/v1/model_providers",
+    schema: listModelProvidersResponseSchema
+  });
+  const createModelProvider = ({ ...body }) => callApi({
+    method: "POST" /* Post */,
+    path: "/api/v1/model_providers",
+    schema: createModelProviderResponseSchema,
+    body
+  });
+  const readModelProvider = ({ model_provider_id }) => callApi({
+    method: "GET" /* Get */,
+    path: `/api/v1/model_providers/${model_provider_id}`,
+    schema: readModelProviderResponseSchema
+  });
+  const deleteModelProvider = ({ model_provider_id }) => callApi({
+    method: "DELETE" /* Delete */,
+    path: `/api/v1/model_providers/${model_provider_id}`,
+    schema: deleteModelProviderResponseSchema
+  });
+  const matchModelProviders = ({ ...body }) => callApi({
+    method: "POST" /* Post */,
+    path: "/api/v1/model_providers/match",
+    schema: matchModelProvidersResponseSchema,
+    body
+  });
+  return {
+    listModelProviders,
+    createModelProvider,
+    readModelProvider,
+    deleteModelProvider,
+    matchModelProviders
+  };
+}
+
+// src/client/api/provider-builds/schemas.ts
+var import_zod35 = __toESM(require("zod"), 1);
+
+// src/client/api/common/schemas.ts
+var import_zod34 = __toESM(require("zod"), 1);
+
+// src/client/api/common/types.ts
+var GitHubVersionType = /* @__PURE__ */ ((GitHubVersionType2) => {
+  GitHubVersionType2["Head"] = "head";
+  GitHubVersionType2["Tag"] = "tag";
+  return GitHubVersionType2;
+})(GitHubVersionType || {});
+
+// src/client/api/common/schemas.ts
+var gitHubVersionTypeSchema = import_zod34.default.enum(GitHubVersionType);
+var gitHubRegistryLocationSchema = import_zod34.default.string();
+var networkRegistryLocationSchema = import_zod34.default.string();
+var fileSystemRegistryLocationSchema = import_zod34.default.string();
+var dockerImageIdSchema = import_zod34.default.string();
+var dockerImageProviderLocationSchema = dockerImageIdSchema;
+var networkProviderLocationSchema = import_zod34.default.string();
+var resolvedGitHubUrlSchema = import_zod34.default.object({
+  host: import_zod34.default.string(),
+  org: import_zod34.default.string(),
+  repo: import_zod34.default.string(),
+  version: import_zod34.default.string(),
+  version_type: gitHubVersionTypeSchema,
+  commit_hash: import_zod34.default.string(),
+  path: import_zod34.default.string().nullish()
+});
+var resolvedDockerImageIdSchema = import_zod34.default.object({
+  registry: import_zod34.default.string(),
+  repository: import_zod34.default.string(),
+  tag: import_zod34.default.string(),
+  digest: import_zod34.default.string(),
+  image_id: dockerImageIdSchema
+});
+var readableStreamSchema = import_zod34.default.custom(
+  (value) => value instanceof ReadableStream,
+  { error: "Expected ReadableStream" }
+);
+
+// src/client/api/provider-builds/types.ts
+var ProviderBuildState = /* @__PURE__ */ ((ProviderBuildState2) => {
+  ProviderBuildState2["Missing"] = "missing";
+  ProviderBuildState2["InProgress"] = "in_progress";
+  ProviderBuildState2["BuildCompleted"] = "build_completed";
+  ProviderBuildState2["Completed"] = "completed";
+  ProviderBuildState2["Failed"] = "failed";
+  return ProviderBuildState2;
+})(ProviderBuildState || {});
+
+// src/client/api/provider-builds/schemas.ts
+var providerBuildStateSchema = import_zod35.default.enum(ProviderBuildState);
+var providerBuildAddActionSchema = import_zod35.default.object({
+  type: import_zod35.default.literal("add_provider"),
+  auto_stop_timeout_sec: import_zod35.default.number().nullish(),
+  variables: import_zod35.default.record(import_zod35.default.string(), import_zod35.default.string()).nullish()
+});
+var providerBuildUpdateActionSchema = import_zod35.default.object({
+  type: import_zod35.default.literal("update_provider"),
+  provider_id: import_zod35.default.string()
+});
+var providerBuildNoActionSchema = import_zod35.default.object({
+  type: import_zod35.default.literal("no_action")
+});
+var providerBuildOnCompleteActionSchema = import_zod35.default.union([
+  providerBuildAddActionSchema,
+  providerBuildUpdateActionSchema,
+  providerBuildNoActionSchema
+]);
+var providerBuildConfigurationSchema = import_zod35.default.object({
+  dockerfile_path: import_zod35.default.string().nullish()
+});
+var providerBuildSchema = import_zod35.default.object({
+  id: import_zod35.default.string(),
+  created_at: import_zod35.default.string(),
+  created_by: import_zod35.default.string(),
+  provider_origin: import_zod35.default.string(),
+  status: providerBuildStateSchema,
+  source: resolvedGitHubUrlSchema,
+  destination: dockerImageIdSchema,
+  on_complete: providerBuildOnCompleteActionSchema,
+  build_configuration: providerBuildConfigurationSchema.nullish(),
+  provider_id: import_zod35.default.string().nullish(),
+  error_message: import_zod35.default.string().nullish()
+});
+var listProviderBuildsRequestSchema = import_zod35.default.object({
+  query: paginationQuerySchema.extend({
+    status: providerBuildStateSchema.nullish(),
+    user_owned: import_zod35.default.boolean().nullish()
+  }).optional()
+});
+var listProviderBuildsResponseSchema = paginatedResponseSchema.extend({
+  items: import_zod35.default.array(providerBuildSchema)
+});
+var createProviderBuildRequestSchema = import_zod35.default.object({
+  location: import_zod35.default.string(),
+  build_configuration: providerBuildConfigurationSchema.nullish(),
+  on_complete: providerBuildOnCompleteActionSchema.optional()
+});
+var createProviderBuildResponseSchema = providerBuildSchema;
+var readProviderBuildRequestSchema = import_zod35.default.object({
+  id: import_zod35.default.string()
+});
+var readProviderBuildResponseSchema = providerBuildSchema;
+var deleteProviderBuildRequestSchema = import_zod35.default.object({
+  id: import_zod35.default.string()
+});
+var deleteProviderBuildResponseSchema = import_zod35.default.null();
+var readProviderBuildLogsRequestSchema = import_zod35.default.object({
+  id: import_zod35.default.string()
+});
+var readProviderBuildLogsResponseSchema = readableStreamSchema;
+var previewProviderBuildRequestSchema = import_zod35.default.object({
+  location: import_zod35.default.string(),
+  build_configuration: providerBuildConfigurationSchema.nullish(),
+  on_complete: providerBuildOnCompleteActionSchema.optional()
+});
+var previewProviderBuildResponseSchema = providerBuildSchema;
+
+// src/client/api/provider-builds/api.ts
+function createProviderBuildsApi(callApi) {
+  const listProviderBuilds = ({ query }) => callApi({
+    method: "GET" /* Get */,
+    path: "/api/v1/provider_builds",
+    schema: listProviderBuildsResponseSchema,
+    query
+  });
+  const createProviderBuild = ({ ...body }) => callApi({
+    method: "POST" /* Post */,
+    path: "/api/v1/provider_builds",
+    schema: createProviderBuildResponseSchema,
+    body
+  });
+  const readProviderBuild = ({ id }) => callApi({
+    method: "GET" /* Get */,
+    path: `/api/v1/provider_builds/${id}`,
+    schema: readProviderBuildResponseSchema
+  });
+  const deleteProviderBuild = ({ id }) => callApi({
+    method: "DELETE" /* Delete */,
+    path: `/api/v1/provider_builds/${id}`,
+    schema: deleteProviderBuildResponseSchema
+  });
+  const readProviderBuildLogs = ({ id }) => callApi({
+    method: "GET" /* Get */,
+    path: `/api/v1/provider_builds/${id}/logs`,
+    schema: readProviderBuildLogsResponseSchema,
+    parseAsStream: true
+  });
+  const previewProviderBuild = ({ ...body }) => callApi({
+    method: "POST" /* Post */,
+    path: "/api/v1/provider_builds/preview",
+    schema: previewProviderBuildResponseSchema,
+    body
+  });
+  return {
+    listProviderBuilds,
+    createProviderBuild,
+    readProviderBuild,
+    deleteProviderBuild,
+    readProviderBuildLogs,
+    previewProviderBuild
+  };
+}
+
+// src/client/api/providers/schemas.ts
+var import_zod36 = __toESM(require("zod"), 1);
+
+// src/client/api/providers/types.ts
+var ProviderType = /* @__PURE__ */ ((ProviderType2) => {
+  ProviderType2["Managed"] = "managed";
+  ProviderType2["Unmanaged"] = "unmanaged";
+  return ProviderType2;
+})(ProviderType || {});
+var ProviderStatus = /* @__PURE__ */ ((ProviderStatus2) => {
+  ProviderStatus2["Missing"] = "missing";
+  ProviderStatus2["Starting"] = "starting";
+  ProviderStatus2["Ready"] = "ready";
+  ProviderStatus2["Running"] = "running";
+  ProviderStatus2["Error"] = "error";
+  return ProviderStatus2;
+})(ProviderStatus || {});
+var ProviderUnmanagedStatus = /* @__PURE__ */ ((ProviderUnmanagedStatus2) => {
+  ProviderUnmanagedStatus2["Online"] = "online";
+  ProviderUnmanagedStatus2["Offline"] = "offline";
+  return ProviderUnmanagedStatus2;
+})(ProviderUnmanagedStatus || {});
+
+// src/client/api/providers/schemas.ts
+var providerTypeSchema = import_zod36.default.enum(ProviderType);
+var providerStatusSchema = import_zod36.default.enum(ProviderStatus);
+var providerUnmanagedStatusSchema = import_zod36.default.enum(ProviderUnmanagedStatus);
+var providerErrorSchema = import_zod36.default.object({
+  message: import_zod36.default.string()
+});
+var providerEnvVarSchema = import_zod36.default.object({
+  name: import_zod36.default.string(),
+  required: import_zod36.default.boolean(),
+  description: import_zod36.default.string().nullish()
+});
+var providerVersionInfoSchema = import_zod36.default.object({
+  docker: resolvedDockerImageIdSchema.nullish(),
+  github: resolvedGitHubUrlSchema.nullish()
+});
+var providerSchema = import_zod36.default.object({
+  id: import_zod36.default.string(),
+  source: import_zod36.default.union([dockerImageProviderLocationSchema, networkProviderLocationSchema]),
+  agent_card: agentCardSchema,
+  state: import_zod36.default.union([providerStatusSchema, providerUnmanagedStatusSchema]),
+  origin: import_zod36.default.string(),
+  created_at: import_zod36.default.string(),
+  created_by: import_zod36.default.string(),
+  updated_at: import_zod36.default.string(),
+  last_active_at: import_zod36.default.string(),
+  auto_stop_timeout: import_zod36.default.string(),
+  managed: import_zod36.default.boolean(),
+  type: providerTypeSchema,
+  env: import_zod36.default.array(providerEnvVarSchema),
+  registry: import_zod36.default.union([gitHubRegistryLocationSchema, networkRegistryLocationSchema, fileSystemRegistryLocationSchema]).nullish(),
+  last_error: providerErrorSchema.nullish(),
+  missing_configuration: import_zod36.default.array(providerEnvVarSchema).optional(),
+  version_info: providerVersionInfoSchema.optional()
+});
+var listProvidersRequestSchema = import_zod36.default.object({
+  query: import_zod36.default.object({
+    origin: import_zod36.default.string().nullish(),
+    user_owned: import_zod36.default.boolean().nullish()
+  }).optional()
+});
+var listProvidersResponseSchema = paginatedResponseSchema.extend({
+  items: import_zod36.default.array(providerSchema)
+});
+var createProviderRequestSchema = import_zod36.default.object({
+  location: import_zod36.default.union([dockerImageProviderLocationSchema, networkProviderLocationSchema]),
+  agent_card: agentCardSchema.nullish(),
+  auto_stop_timeout_sec: import_zod36.default.number().nullish(),
+  origin: import_zod36.default.string().nullish(),
+  variables: import_zod36.default.record(import_zod36.default.string(), import_zod36.default.string()).nullish()
+});
+var createProviderResponseSchema = providerSchema;
+var readProviderRequestSchema = import_zod36.default.object({
+  id: import_zod36.default.string()
+});
+var readProviderResponseSchema = providerSchema;
+var deleteProviderRequestSchema = import_zod36.default.object({
+  id: import_zod36.default.string()
+});
+var deleteProviderResponseSchema = import_zod36.default.null();
+var patchProviderRequestSchema = import_zod36.default.object({
+  id: import_zod36.default.string(),
+  location: import_zod36.default.union([dockerImageProviderLocationSchema, networkProviderLocationSchema]).nullish(),
+  agent_card: agentCardSchema.nullish(),
+  auto_stop_timeout_sec: import_zod36.default.number().nullish(),
+  origin: import_zod36.default.string().nullish(),
+  variables: import_zod36.default.record(import_zod36.default.string(), import_zod36.default.string()).nullish()
+});
+var patchProviderResponseSchema = providerSchema;
+var readProviderLogsRequestSchema = import_zod36.default.object({
+  id: import_zod36.default.string()
+});
+var readProviderLogsResponseSchema = readableStreamSchema;
+var listProviderVariablesRequestSchema = import_zod36.default.object({
+  id: import_zod36.default.string()
+});
+var listProviderVariablesResponseSchema = import_zod36.default.object({
+  variables: import_zod36.default.record(import_zod36.default.string(), import_zod36.default.string())
+});
+var updateProviderVariablesRequestSchema = import_zod36.default.object({
+  id: import_zod36.default.string(),
+  variables: import_zod36.default.record(import_zod36.default.string(), import_zod36.default.union([import_zod36.default.string(), import_zod36.default.null()]))
+});
+var updateProviderVariablesResponseSchema = import_zod36.default.null();
+var readProviderByLocationRequestSchema = import_zod36.default.object({
+  location: import_zod36.default.string()
+});
+var readProviderByLocationResponseSchema = providerSchema;
+var previewProviderResponseSchema = providerSchema;
+
+// src/client/api/providers/api.ts
+function createProvidersApi(callApi) {
+  const listProviders = ({ query }) => callApi({
+    method: "GET" /* Get */,
+    path: "/api/v1/providers",
+    schema: listProvidersResponseSchema,
+    query
+  });
+  const createProvider = ({ ...body }) => callApi({
+    method: "POST" /* Post */,
+    path: "/api/v1/providers",
+    schema: createProviderResponseSchema,
+    body
+  });
+  const readProvider = ({ id }) => callApi({
+    method: "GET" /* Get */,
+    path: `/api/v1/providers/${id}`,
+    schema: readProviderResponseSchema
+  });
+  const deleteProvider = ({ id }) => callApi({
+    method: "DELETE" /* Delete */,
+    path: `/api/v1/providers/${id}`,
+    schema: deleteProviderResponseSchema
+  });
+  const patchProvider = ({ id, ...body }) => callApi({
+    method: "PATCH" /* Patch */,
+    path: `/api/v1/providers/${id}`,
+    schema: patchProviderResponseSchema,
+    body
+  });
+  const readProviderLogs = ({ id }) => callApi({
+    method: "GET" /* Get */,
+    path: `/api/v1/providers/${id}/logs`,
+    schema: readProviderLogsResponseSchema,
+    parseAsStream: true
+  });
+  const listProviderVariables = ({ id }) => callApi({
+    method: "GET" /* Get */,
+    path: `/api/v1/providers/${id}/variables`,
+    schema: listProviderVariablesResponseSchema
+  });
+  const updateProviderVariables = ({ id, ...body }) => callApi({
+    method: "PUT" /* Put */,
+    path: `/api/v1/providers/${id}/variables`,
+    schema: updateProviderVariablesResponseSchema,
+    body
+  });
+  const readProviderByLocation = ({ location }) => callApi({
+    method: "GET" /* Get */,
+    path: `/api/v1/providers/by-location/${location}`,
+    schema: readProviderByLocationResponseSchema
+  });
+  const previewProvider = ({ ...body }) => callApi({
+    method: "POST" /* Post */,
+    path: "/api/v1/providers/preview",
+    schema: previewProviderResponseSchema,
+    body
+  });
+  return {
+    listProviders,
+    createProvider,
+    readProvider,
+    deleteProvider,
+    patchProvider,
+    readProviderLogs,
+    listProviderVariables,
+    updateProviderVariables,
+    readProviderByLocation,
+    previewProvider
+  };
+}
+
+// src/client/api/user-feedback/schemas.ts
+var import_zod37 = __toESM(require("zod"), 1);
+var createUserFeedbackRequestSchema = import_zod37.default.object({
+  provider_id: import_zod37.default.string(),
+  context_id: import_zod37.default.string(),
+  task_id: import_zod37.default.string(),
+  message: import_zod37.default.string(),
+  rating: import_zod37.default.union([import_zod37.default.literal(1), import_zod37.default.literal(-1)]),
+  comment: import_zod37.default.string().nullish(),
+  comment_tags: import_zod37.default.array(import_zod37.default.string()).nullish()
+});
+var createUserFeedbackResponseSchema = import_zod37.default.null();
+
+// src/client/api/user-feedback/api.ts
+function createUserFeedbackApi(callApi) {
+  const createUserFeedback = ({ ...body }) => callApi({
+    method: "POST" /* Post */,
+    path: "/api/v1/user_feedback",
+    schema: createUserFeedbackResponseSchema,
+    body
+  });
+  return {
+    createUserFeedback
+  };
+}
+
+// src/client/api/users/schemas.ts
+var import_zod38 = __toESM(require("zod"), 1);
+
+// src/client/api/users/types.ts
+var UserRole = /* @__PURE__ */ ((UserRole2) => {
+  UserRole2["Admin"] = "admin";
+  UserRole2["Developer"] = "developer";
+  UserRole2["User"] = "user";
+  return UserRole2;
+})(UserRole || {});
+
+// src/client/api/users/schemas.ts
+var userRoleSchema = import_zod38.default.enum(UserRole);
+var userSchema = import_zod38.default.object({
+  id: import_zod38.default.string(),
+  role: userRoleSchema,
+  email: import_zod38.default.string(),
+  created_at: import_zod38.default.string()
+});
+var readUserRequestSchema = import_zod38.default.never();
+var readUserResponseSchema = userSchema;
+
+// src/client/api/users/api.ts
+function createUsersApi(callApi) {
+  const readUser = () => callApi({
+    method: "GET" /* Get */,
+    path: "/api/v1/user",
+    schema: readUserResponseSchema
+  });
+  return {
+    readUser
+  };
+}
+
+// src/client/api/variables/schemas.ts
+var import_zod39 = __toESM(require("zod"), 1);
+var listVariablesRequestSchema = import_zod39.default.never();
+var listVariablesResponseSchema = import_zod39.default.object({
+  variables: import_zod39.default.record(import_zod39.default.string(), import_zod39.default.string())
+});
+var updateVariablesRequestSchema = import_zod39.default.object({
+  variables: import_zod39.default.record(import_zod39.default.string(), import_zod39.default.union([import_zod39.default.string(), import_zod39.default.null()]))
+});
+var updateVariablesResponseSchema = import_zod39.default.null();
+
+// src/client/api/variables/api.ts
+function createVariablesApi(callApi) {
+  const listVariables = () => callApi({
+    method: "GET" /* Get */,
+    path: "/api/v1/variables",
+    schema: listVariablesResponseSchema
+  });
+  const updateVariables = ({ ...body }) => callApi({
+    method: "PUT" /* Put */,
+    path: "/api/v1/variables",
+    schema: updateVariablesResponseSchema,
+    body
+  });
+  return {
+    listVariables,
+    updateVariables
+  };
+}
+
+// src/client/api/core/utils.ts
+function buildRequestUrl({ baseUrl, path, query }) {
+  const url = `${baseUrl.replace(/\/+$/, "")}${path}`;
+  if (query) {
+    const searchParams = new URLSearchParams();
+    Object.entries(query).forEach(([key, value]) => {
+      if (value != null) {
+        searchParams.append(key, String(value));
+      }
+    });
+    const queryString = searchParams.toString();
+    if (queryString) {
+      return `${url}?${queryString}`;
+    }
+  }
+  return url;
+}
+function buildRequestInit({ method, body }) {
+  const headers = new Headers();
+  let requestBody;
+  if (body) {
+    if (body instanceof FormData) {
+      requestBody = body;
+    } else {
+      headers.set("Content-Type", "application/json");
+      requestBody = JSON.stringify(body);
+    }
+  }
+  return {
+    method,
+    headers,
+    body: requestBody
+  };
+}
+async function safeReadText(response) {
+  try {
+    return await response.text();
+  } catch {
+    return null;
+  }
+}
+function parseBodyText(bodyText, headers) {
+  const isStreamResponse = bodyText instanceof ReadableStream;
+  if (isStreamResponse) {
+    return {
+      data: bodyText
+    };
+  }
+  if (bodyText == null || bodyText.trim() === "") {
+    return {
+      data: null
+    };
+  }
+  const contentType = headers.get("content-type") ?? "";
+  const isJsonResponse = contentType.includes("application/json");
+  if (isJsonResponse) {
+    try {
+      return {
+        data: JSON.parse(bodyText)
+      };
+    } catch (error) {
+      return {
+        data: null,
+        error: error instanceof Error ? error : new Error("Failed to parse body text.")
+      };
+    }
+  }
+  return {
+    data: bodyText
+  };
+}
+
+// src/client/api/core/client.ts
+function createCallApi({ baseUrl, fetch: fetchFn }) {
+  return async function callApi({ method, path, schema, query, body, parseAsStream }) {
+    const requestUrl = buildRequestUrl({ baseUrl, path, query });
+    const requestInit = buildRequestInit({ method, body });
+    const request = {
+      method,
+      url: requestUrl
+    };
+    try {
+      const rawResponse = await fetchFn(requestUrl, requestInit);
+      const bodyText = parseAsStream ? rawResponse.body : await safeReadText(rawResponse);
+      const { ok, status, statusText, headers } = rawResponse;
+      const response = { status, statusText, bodyText };
+      if (!ok) {
+        return {
+          ok: false,
+          error: {
+            type: "http" /* Http */,
+            message: "API Http Error",
+            request,
+            response
+          }
+        };
+      }
+      const { data: parsedBody, error: parseError } = parseBodyText(bodyText, headers);
+      if (parseError) {
+        return {
+          ok: false,
+          error: {
+            type: "parse" /* Parse */,
+            message: "API Parse Error",
+            request,
+            response,
+            details: parseError
+          }
+        };
+      }
+      const { data: result, success, error } = schema.safeParse(parsedBody);
+      if (!success) {
+        return {
+          ok: false,
+          error: {
+            type: "validation" /* Validation */,
+            message: "API Validation Error",
+            request,
+            response,
+            details: error
+          }
+        };
+      }
+      return {
+        ok: true,
+        data: result,
+        response
+      };
+    } catch (details) {
+      return {
+        ok: false,
+        error: {
+          type: "network" /* Network */,
+          message: "API Network Error",
+          request,
+          details
+        }
+      };
+    }
+  };
+}
+var buildApiClient = ({
+  baseUrl,
+  fetch: fetchFn
+} = { baseUrl: "" }) => {
+  const maybeFetch = fetchFn ?? (typeof globalThis.fetch !== "undefined" ? globalThis.fetch : void 0);
+  if (!maybeFetch) {
+    throw new Error(
+      "fetch is not available. In Node.js < 18 or environments without global fetch, provide a fetch implementation via the fetch option."
+    );
+  }
+  const callApi = createCallApi({ baseUrl, fetch: maybeFetch });
+  const configurationApi = createConfigurationApi(callApi);
+  const connectorsApi = createConnectorsApi(callApi);
+  const contextsApi = createContextsApi(callApi);
+  const filesApi = createFilesApi(callApi);
+  const modelProvidersApi = createModelProvidersApi(callApi);
+  const providerBuildsApi = createProviderBuildsApi(callApi);
+  const providersApi = createProvidersApi(callApi);
+  const userFeedbackApi = createUserFeedbackApi(callApi);
+  const usersApi = createUsersApi(callApi);
+  const variablesApi = createVariablesApi(callApi);
+  return {
+    ...configurationApi,
+    ...connectorsApi,
+    ...contextsApi,
+    ...filesApi,
+    ...modelProvidersApi,
+    ...providerBuildsApi,
+    ...providersApi,
+    ...userFeedbackApi,
+    ...usersApi,
+    ...variablesApi
+  };
+};
+
+// src/experimental/server/core/utils.ts
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function withRetry(fn, options = {}) {
+  const { maxAttempts = 10, maxDelayMs = 1e4, shouldAbort, onRetry } = options;
+  let lastError;
+  for (let attempt = 0; attempt < maxAttempts; attempt++) {
+    if (shouldAbort?.()) {
+      throw new Error("Operation aborted");
+    }
+    try {
+      return await fn();
+    } catch (error) {
+      lastError = error instanceof Error ? error : new Error(String(error));
+      const delay = Math.min(1e3 * Math.pow(2, attempt), maxDelayMs);
+      onRetry?.(attempt + 1, lastError, delay);
+      await sleep(delay);
+    }
+  }
+  throw lastError ?? new Error("Max retry attempts exceeded");
+}
+function setsEqual(a, b) {
+  if (a.size !== b.size) {
+    return false;
+  }
+  for (const item of a) {
+    if (!b.has(item)) {
+      return false;
+    }
+  }
+  return true;
+}
+function getErrorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+// src/experimental/server/core/server/helpers.ts
+function createAgentCardUrl(host, port, selfRegistrationId) {
+  return `http://${host === "0.0.0.0" ? "localhost" : host}:${port}${selfRegistrationId ? `#${selfRegistrationId}` : ""}`;
+}
+function normalizeDockerHost(host) {
+  return host.replace(/0\.0\.0\.0|localhost|127\.0\.0\.1/g, "host.docker.internal");
+}
+
+// src/experimental/server/core/server/autoregistration.ts
+var VARIABLE_RELOAD_INTERVAL_MS = 5e3;
+function createAutoregisterToAgentstack(options) {
+  const { selfRegistrationId, agentCard, host, port, api } = options;
+  let providerId = null;
+  let variableReloadInterval = null;
+  let configuredVariables = /* @__PURE__ */ new Set();
+  let stopped = false;
+  async function loadVariables(firstRun = false) {
+    if (!providerId) {
+      return;
+    }
+    try {
+      const result = await api.listProviderVariables({ id: providerId });
+      if (!result.ok) {
+        console.warn(`Failed to load variables: ${result.error.message}`);
+        return;
+      }
+      const variables = result.data.variables;
+      const oldVariables = configuredVariables;
+      const newVariables = /* @__PURE__ */ new Set();
+      for (const variable of configuredVariables) {
+        if (!(variable in variables)) {
+          delete process.env[variable];
+        }
+      }
+      for (const [key, value] of Object.entries(variables)) {
+        process.env[key] = value;
+        newVariables.add(key);
+      }
+      const dirty = !setsEqual(oldVariables, newVariables);
+      configuredVariables = newVariables;
+      if (dirty && configuredVariables.size > 0) {
+        console.log(`Environment variables reloaded: ${[...configuredVariables].join(", ")}`);
+      }
+      if (firstRun && configuredVariables.size > 0) {
+        console.log("Environment variables loaded.");
+      }
+    } catch (error) {
+      console.error(`Failed to load variables: ${getErrorMessage(error)}`);
+    }
+  }
+  async function register() {
+    if (isProductionMode()) {
+      console.log("Agent is not automatically registered in production mode.");
+      return;
+    }
+    const location = createAgentCardUrl(normalizeDockerHost(host), port, selfRegistrationId);
+    console.log("Registering agent to the Agent Stack platform", { location });
+    try {
+      await withRetry(
+        async () => {
+          const existingResult = await api.readProviderByLocation({
+            location: encodeURIComponent(location)
+          });
+          if (existingResult.ok) {
+            const patchResult = await api.patchProvider({
+              id: existingResult.data.id,
+              agent_card: agentCard
+            });
+            if (!patchResult.ok) {
+              throw new Error(`Failed to patch provider: ${patchResult.error.message}`);
+            }
+            providerId = patchResult.data.id;
+          } else if (existingResult.error.type === "http" /* Http */ && existingResult.error.response.status === 404) {
+            const createResult = await api.createProvider({
+              location,
+              agent_card: agentCard
+            });
+            if (!createResult.ok) {
+              throw new Error(`Failed to create provider: ${createResult.error.message}`);
+            }
+            providerId = createResult.data.id;
+          } else {
+            throw new Error(`Failed to lookup provider: ${existingResult.error.message}`);
+          }
+        },
+        {
+          shouldAbort: () => stopped,
+          onRetry: (attempt, _error, delayMs) => {
+            console.warn(`Registration attempt ${attempt} failed, retrying in ${delayMs}ms...`);
+          }
+        }
+      );
+      console.log("Agent registered successfully");
+      await loadVariables(true);
+      variableReloadInterval = setInterval(() => {
+        loadVariables().catch((error) => console.error("Error during variable reload:", error));
+      }, VARIABLE_RELOAD_INTERVAL_MS);
+    } catch (error) {
+      console.error(`Agent cannot be registered to agentstack server: ${getErrorMessage(error)}`);
+    }
+  }
+  function stop() {
+    stopped = true;
+    if (variableReloadInterval) {
+      clearInterval(variableReloadInterval);
+      variableReloadInterval = null;
+    }
+  }
+  register();
+  return stop;
+}
+
+// src/experimental/server/a2a/helpers.ts
+var import_crypto = require("crypto");
+function createMessage({
+  taskId,
+  contextId,
+  parts,
+  metadata
+}) {
+  return {
+    kind: "message",
+    messageId: (0, import_crypto.randomUUID)(),
+    role: "agent",
+    taskId,
+    contextId,
+    parts,
+    metadata
+  };
+}
+function createTextPart(text) {
+  return {
+    kind: "text",
+    text
+  };
+}
+function createDataPart(data) {
+  return {
+    kind: "data",
+    data
+  };
+}
+function createStatusUpdateEvent({
+  taskId,
+  contextId,
+  status,
+  final
+}) {
+  return {
+    kind: "status-update",
+    taskId,
+    contextId,
+    status,
+    final
+  };
+}
+function createArtifactUpdateEvent({
+  taskId,
+  contextId,
+  artifact,
+  lastChunk,
+  append
+}) {
+  return {
+    kind: "artifact-update",
+    taskId,
+    contextId,
+    artifact,
+    lastChunk,
+    append
+  };
+}
+
+// src/experimental/server/a2a/utils.ts
+function isObjectLike(value) {
+  return value != null && typeof value === "object";
+}
+function isAsyncIterable(value) {
+  return isObjectLike(value) && Symbol.asyncIterator in value;
+}
+function isMessage(value) {
+  return isObjectLike(value) && "kind" in value && value.kind === "message";
+}
+function isArtifact(value) {
+  return isObjectLike(value) && "artifactId" in value;
+}
+function isPart(value) {
+  return isObjectLike(value) && "kind" in value && typeof value.kind === "string" && ["text", "file", "data"].includes(value.kind);
+}
+function isTaskStatus(value) {
+  return isObjectLike(value) && "state" in value;
+}
+function isTaskStatusUpdateEvent(value) {
+  return isObjectLike(value) && "kind" in value && value.kind === "status-update";
+}
+
+// src/experimental/server/core/server/executor.ts
+var AgentExecutorImpl = class {
+  handler;
+  extensions;
+  runningTasks = /* @__PURE__ */ new Map();
+  constructor(handler, extensions) {
+    this.handler = handler;
+    this.extensions = extensions;
+  }
+  getOrCreateTask(requestContext, eventBus) {
+    const { taskId, contextId, task } = requestContext;
+    if (task) {
+      return task;
+    }
+    const initialTask = {
+      kind: "task",
+      id: taskId,
+      contextId,
+      status: {
+        state: "submitted",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      },
+      history: []
+    };
+    eventBus.publish(initialTask);
+    eventBus.publish(
+      createStatusUpdateEvent({
+        taskId: initialTask.id,
+        contextId,
+        status: {
+          state: "working"
+        },
+        final: false
+      })
+    );
+    return initialTask;
+  }
+  async execute(requestContext, eventBus) {
+    const { userMessage, contextId } = requestContext;
+    const task = this.getOrCreateTask(requestContext, eventBus);
+    const runContext = new RunContext(task.id, contextId, task);
+    const taskState = { cancelled: false };
+    this.runningTasks.set(task.id, taskState);
+    try {
+      const deps = this.resolveExtensions(userMessage);
+      const result = this.handler(userMessage, runContext, deps);
+      if (isAsyncIterable(result)) {
+        for await (const yielded of result) {
+          if (taskState.cancelled) {
+            this.publishCancelled(eventBus, task.id, contextId);
+            return;
+          }
+          this.processYield(eventBus, task.id, contextId, yielded);
+        }
+      } else {
+        const awaited = await result;
+        if (awaited !== void 0) {
+          this.processYield(eventBus, task.id, contextId, awaited);
+        }
+      }
+      if (!taskState.cancelled) {
+        eventBus.publish(
+          createStatusUpdateEvent({
+            taskId: task.id,
+            contextId,
+            status: {
+              state: "completed"
+            },
+            final: true
+          })
+        );
+      }
+    } catch (error) {
+      const message = createMessage({
+        taskId: task.id,
+        contextId,
+        parts: [createTextPart(error instanceof Error ? error.message : "Unknown error")]
+      });
+      eventBus.publish(
+        createStatusUpdateEvent({
+          taskId: task.id,
+          contextId,
+          status: {
+            state: "failed",
+            message
+          },
+          final: true
+        })
+      );
+      this.runningTasks.delete(task.id);
+    } finally {
+      eventBus.finished();
+    }
+  }
+  async cancelTask(taskId) {
+    const taskState = this.runningTasks.get(taskId);
+    if (taskState) {
+      taskState.cancelled = true;
+    }
+  }
+  resolveExtensions(message) {
+    if (!this.extensions) {
+      return {};
+    }
+    const deps = {};
+    for (const [key, ext] of Object.entries(this.extensions)) {
+      const fulfillments = ext.spec.parseFulfillments(message);
+      deps[key] = ext.resolveDeps(fulfillments);
+    }
+    return deps;
+  }
+  publishCancelled(eventBus, taskId, contextId) {
+    eventBus.publish(
+      createStatusUpdateEvent({
+        taskId,
+        contextId,
+        status: {
+          state: "canceled"
+        },
+        final: true
+      })
+    );
+  }
+  processYield(eventBus, taskId, contextId, yielded) {
+    if (typeof yielded === "string") {
+      const message = createMessage({
+        taskId,
+        contextId,
+        parts: [createTextPart(yielded)]
+      });
+      eventBus.publish(
+        createStatusUpdateEvent({
+          taskId,
+          contextId,
+          status: {
+            state: "working",
+            message
+          },
+          final: false
+        })
+      );
+    } else if (yielded instanceof Error) {
+      const message = createMessage({
+        taskId,
+        contextId,
+        parts: [createTextPart(yielded.message)]
+      });
+      eventBus.publish(
+        createStatusUpdateEvent({
+          taskId,
+          contextId,
+          status: {
+            state: "failed",
+            message
+          },
+          final: true
+        })
+      );
+    } else if (isMessage(yielded)) {
+      const message = {
+        ...yielded,
+        taskId,
+        contextId
+      };
+      eventBus.publish(
+        createStatusUpdateEvent({
+          taskId,
+          contextId,
+          status: {
+            state: "working",
+            message
+          },
+          final: false
+        })
+      );
+    } else if (isPart(yielded)) {
+      const message = createMessage({
+        taskId,
+        contextId,
+        parts: [yielded]
+      });
+      eventBus.publish(
+        createStatusUpdateEvent({
+          taskId,
+          contextId,
+          status: {
+            state: "working",
+            message
+          },
+          final: false
+        })
+      );
+    } else if (isTaskStatusUpdateEvent(yielded)) {
+      eventBus.publish(yielded);
+    } else if (isTaskStatus(yielded)) {
+      eventBus.publish(
+        createStatusUpdateEvent({
+          taskId,
+          contextId,
+          status: yielded,
+          final: false
+        })
+      );
+    } else if (isArtifact(yielded)) {
+      eventBus.publish(
+        createArtifactUpdateEvent({
+          taskId,
+          contextId,
+          artifact: yielded,
+          lastChunk: true,
+          append: false
+        })
+      );
+    } else if (typeof yielded === "object" && yielded != null) {
+      const message = createMessage({
+        taskId,
+        contextId,
+        parts: [createDataPart(yielded)]
+      });
+      eventBus.publish(
+        createStatusUpdateEvent({
+          taskId,
+          contextId,
+          status: {
+            state: "working",
+            message
+          },
+          final: false
+        })
+      );
+    }
+  }
+};
+
+// src/experimental/server/core/server/index.ts
+var Server = class {
+  agentCard;
+  agentOptions;
+  agentConfigured = false;
+  agent(options) {
+    if (this.agentConfigured) {
+      throw new Error("Agent already configured. Only one agent per server is supported.");
+    }
+    let extensions = this.buildExtensions(options.extensions);
+    if (options.detail) {
+      const detailExt = new AgentDetailExtensionSpec(options.detail);
+      extensions = [...extensions ?? [], detailExt.toAgentCardExtension()];
+    }
+    this.agentCard = {
+      name: options.name,
+      description: options.description ?? "",
+      url: "http://localhost:8000",
+      version: options.version ?? "1.0.0",
+      protocolVersion: options.protocolVersion ?? "0.3.0",
+      capabilities: {
+        streaming: true,
+        extensions
+      },
+      defaultInputModes: ["text"],
+      defaultOutputModes: ["text"],
+      skills: []
+    };
+    this.agentOptions = options;
+    this.agentConfigured = true;
+    return this;
+  }
+  async run(options = {}) {
+    if (!this.agentConfigured || !this.agentCard || !this.agentOptions) {
+      throw new Error("No agent configured. Call agent() before run().");
+    }
+    const config = loadConfig();
+    const host = options.host ?? "0.0.0.0";
+    const port = options.port ?? 8e3;
+    const selfRegistrationId = options.selfRegistrationId;
+    const platformUrl = options.platformUrl ?? config.platformUrl;
+    const productionMode = config.productionMode;
+    this.agentCard.url = createAgentCardUrl(host, port);
+    if (selfRegistrationId && !productionMode) {
+      const selfRegExtension = new PlatformSelfRegistrationExtensionSpec({ self_registration_id: selfRegistrationId });
+      this.agentCard.capabilities.extensions = [
+        ...this.agentCard.capabilities.extensions ?? [],
+        selfRegExtension.toAgentCardExtension()
+      ];
+    }
+    const taskStore = new import_server.InMemoryTaskStore();
+    const executor = new AgentExecutorImpl(this.agentOptions.handler, this.agentOptions.extensions);
+    const requestHandler = new import_server.DefaultRequestHandler(this.agentCard, taskStore, executor);
+    const app = (0, import_express2.default)();
+    const agentCardPath = `/.well-known/agent-card.json`;
+    app.use((0, import_express.jsonRpcHandler)({ requestHandler, userBuilder: import_express.UserBuilder.noAuthentication }));
+    app.use(agentCardPath, (0, import_express.agentCardHandler)({ agentCardProvider: requestHandler }));
+    const api = buildApiClient({ baseUrl: platformUrl });
+    let stopAutoregistration;
+    if (selfRegistrationId && !productionMode) {
+      stopAutoregistration = createAutoregisterToAgentstack({
+        selfRegistrationId,
+        agentCard: this.agentCard,
+        host,
+        port,
+        api
+      });
+    }
+    return new Promise((resolve, reject) => {
+      const server = app.listen(port, host, async () => {
+        console.log(`Agent "${this.agentCard.name}" running at http://${host}:${port}`);
+        console.log(`Agent card available at http://${host}:${port}${agentCardPath}`);
+        const url = createAgentCardUrl(host, port);
+        const handle = {
+          port,
+          url,
+          close: () => new Promise((resolveClose, rejectClose) => {
+            stopAutoregistration?.();
+            server.close((error) => {
+              if (error) {
+                rejectClose(error);
+              } else {
+                resolveClose();
+              }
+            });
+          })
+        };
+        resolve(handle);
+      });
+      server.on("error", (error) => {
+        stopAutoregistration?.();
+        reject(error);
+      });
+      const cleanup = () => {
+        stopAutoregistration?.();
+        server.close();
+      };
+      process.on("SIGTERM", cleanup);
+      process.on("SIGINT", cleanup);
+    });
+  }
+  buildExtensions(extensionConfig) {
+    if (!extensionConfig) {
+      return void 0;
+    }
+    const extensions = [];
+    for (const ext of Object.values(extensionConfig)) {
+      extensions.push(ext.spec.toAgentCardExtension());
+    }
+    if (extensions.length === 0) {
+      return void 0;
+    }
+    return extensions;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AgentDetailExtensionSpec,
+  LLMExtensionServer,
+  LLMExtensionSpec,
+  PLATFORM_SELF_REGISTRATION_EXTENSION_URI,
+  PlatformSelfRegistrationExtensionSpec,
+  RunContext,
+  Server,
+  configSchema,
+  isProductionMode,
+  loadConfig
+});