agentstack-sdk 0.6.1 → 0.6.2-rc2

package/dist/server.js

@@ -0,0 +1,2716 @@
+// src/client/a2a/extensions/auth/oauth/index.ts
+import z2 from "zod";
+
+// src/client/a2a/extensions/auth/oauth/schemas.ts
+import z from "zod";
+var oauthDemandSchema = z.object({
+  redirect_uri: z.boolean()
+});
+var oauthDemandsSchema = z.object({
+  oauth_demands: z.record(z.string(), oauthDemandSchema)
+});
+var oauthFulfillmentSchema = z.object({
+  redirect_uri: z.string()
+});
+var oauthFulfillmentsSchema = z.object({
+  oauth_fulfillments: z.record(z.string(), oauthFulfillmentSchema)
+});
+var oauthRequestSchema = z.object({
+  authorization_endpoint_url: z.string()
+});
+var oauthResponseSchema = z.object({
+  redirect_uri: z.string()
+});
+var oauthMessageSchema = z.object({
+  data: oauthResponseSchema
+});
+
+// src/client/a2a/extensions/auth/secrets/index.ts
+import z4 from "zod";
+
+// src/client/a2a/extensions/auth/secrets/schemas.ts
+import z3 from "zod";
+var secretDemandSchema = z3.object({
+  name: z3.string(),
+  description: z3.string().nullish()
+});
+var secretDemandsSchema = z3.object({
+  secret_demands: z3.record(z3.string(), secretDemandSchema)
+});
+var secretFulfillmentSchema = z3.object({
+  secret: z3.string()
+});
+var secretFulfillmentsSchema = z3.object({
+  secret_fulfillments: z3.record(z3.string(), secretFulfillmentSchema)
+});
+
+// src/client/a2a/extensions/interactions/approval/index.ts
+import z6 from "zod";
+
+// src/client/a2a/extensions/interactions/approval/schemas.ts
+import z5 from "zod";
+
+// 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 = z5.object({
+  action: z5.literal("generic"),
+  title: z5.string().nullish().describe("A human-readable title for the action being approved."),
+  description: z5.string().nullish().describe("A human-readable description of the action being approved.")
+});
+var toolCallApprovalRequestSchema = z5.object({
+  action: z5.literal("tool-call"),
+  title: z5.string().nullish().describe("A human-readable title of the tool."),
+  description: z5.string().nullish().describe("A human-readable description of the tool."),
+  name: z5.string().describe("The programmatic name of the tool."),
+  input: z5.object().nullish().describe("The input for the tool."),
+  server: z5.object({
+    name: z5.string().describe("The programmatic name of the server."),
+    title: z5.string().nullish().describe("A human-readable title for the server."),
+    version: z5.string().describe("The version of the server.")
+  }).nullish().describe("The server executing the tool.")
+});
+var approvalRequestSchema = z5.discriminatedUnion("action", [
+  genericApprovalRequestSchema,
+  toolCallApprovalRequestSchema
+]);
+var approvalDecisionSchema = z5.enum(ApprovalDecision);
+var approvalResponseSchema = z5.object({
+  decision: approvalDecisionSchema
+});
+
+// src/client/a2a/extensions/common/form/schemas.ts
+import z7 from "zod";
+var baseFieldSchema = z7.object({
+  id: z7.string().nonempty(),
+  label: z7.string().nonempty(),
+  required: z7.boolean().nullish(),
+  col_span: z7.int().min(1).max(4).nullish()
+});
+var textFieldSchema = baseFieldSchema.extend({
+  type: z7.literal("text"),
+  placeholder: z7.string().nullish(),
+  default_value: z7.string().nullish(),
+  auto_resize: z7.boolean().default(true).nullish()
+});
+var dateFieldSchema = baseFieldSchema.extend({
+  type: z7.literal("date"),
+  placeholder: z7.string().nullish(),
+  default_value: z7.string().nullish()
+});
+var fileFieldSchema = baseFieldSchema.extend({
+  type: z7.literal("file"),
+  accept: z7.array(z7.string())
+});
+var selectFieldOptionSchema = z7.object({
+  id: z7.string().nonempty(),
+  label: z7.string().nonempty()
+});
+var singleSelectFieldSchema = baseFieldSchema.extend({
+  type: z7.literal("singleselect"),
+  options: z7.array(selectFieldOptionSchema).nonempty(),
+  default_value: z7.string().nullish()
+});
+var multiSelectFieldSchema = baseFieldSchema.extend({
+  type: z7.literal("multiselect"),
+  options: z7.array(selectFieldOptionSchema).nonempty(),
+  default_value: z7.array(z7.string()).nullish()
+});
+var checkboxFieldSchema = baseFieldSchema.extend({
+  type: z7.literal("checkbox"),
+  content: z7.string(),
+  default_value: z7.boolean().nullish()
+});
+var formFieldSchema = z7.discriminatedUnion("type", [
+  textFieldSchema,
+  dateFieldSchema,
+  fileFieldSchema,
+  singleSelectFieldSchema,
+  multiSelectFieldSchema,
+  checkboxFieldSchema
+]);
+var textFieldValueSchema = z7.object({
+  type: textFieldSchema.shape.type,
+  value: z7.string().nullish()
+});
+var dateFieldValueSchema = z7.object({
+  type: dateFieldSchema.shape.type,
+  value: z7.string().nullish()
+});
+var fileFieldValueSchema = z7.object({
+  type: fileFieldSchema.shape.type,
+  value: z7.array(
+    z7.object({
+      uri: z7.string(),
+      name: z7.string().nullish(),
+      mime_type: z7.string().nullish()
+    })
+  ).nullish()
+});
+var singleSelectFieldValueSchema = z7.object({
+  type: singleSelectFieldSchema.shape.type,
+  value: z7.string().nullish()
+});
+var multiSelectFieldValueSchema = z7.object({
+  type: multiSelectFieldSchema.shape.type,
+  value: z7.array(z7.string()).nullish()
+});
+var checkboxFieldValueSchema = z7.object({
+  type: checkboxFieldSchema.shape.type,
+  value: z7.boolean().nullish()
+});
+var formFieldValueSchema = z7.discriminatedUnion("type", [
+  textFieldValueSchema,
+  dateFieldValueSchema,
+  fileFieldValueSchema,
+  singleSelectFieldValueSchema,
+  multiSelectFieldValueSchema,
+  checkboxFieldValueSchema
+]);
+var formRenderSchema = z7.object({
+  fields: z7.array(formFieldSchema).nonempty(),
+  title: z7.string().nullish(),
+  description: z7.string().nullish(),
+  columns: z7.int().min(1).max(4).nullish(),
+  submit_label: z7.string().nullish()
+});
+var formValuesSchema = z7.record(z7.string(), formFieldValueSchema);
+var formResponseSchema = z7.object({
+  values: formValuesSchema
+});
+
+// src/client/a2a/extensions/services/embedding/schemas.ts
+import z8 from "zod";
+var embeddingDemandSchema = z8.object({
+  description: z8.string().nullish(),
+  suggested: z8.array(z8.string()).nullish()
+});
+var embeddingDemandsSchema = z8.object({
+  embedding_demands: z8.record(z8.string(), embeddingDemandSchema)
+});
+var embeddingFulfillmentSchema = z8.object({
+  identifier: z8.string().nullish(),
+  api_base: z8.string(),
+  api_key: z8.string(),
+  api_model: z8.string()
+});
+var embeddingFulfillmentsSchema = z8.object({
+  embedding_fulfillments: z8.record(z8.string(), embeddingFulfillmentSchema)
+});
+
+// src/client/a2a/extensions/services/form/schemas.ts
+import z9 from "zod";
+var formDemandsSchema = z9.object({
+  form_demands: z9.object({
+    initial_form: formRenderSchema
+  }).partial()
+});
+var formFulfillmentsSchema = z9.object({
+  form_fulfillments: z9.record(z9.string(), formResponseSchema)
+});
+
+// src/client/a2a/extensions/services/llm/schemas.ts
+import z10 from "zod";
+var llmDemandSchema = z10.object({
+  description: z10.string().nullish(),
+  suggested: z10.array(z10.string()).nullish()
+});
+var llmDemandsSchema = z10.object({
+  llm_demands: z10.record(z10.string(), llmDemandSchema)
+});
+var llmFulfillmentSchema = z10.object({
+  identifier: z10.string().nullish(),
+  api_base: z10.string(),
+  api_key: z10.string(),
+  api_model: z10.string()
+});
+var llmFulfillmentsSchema = z10.object({
+  llm_fulfillments: z10.record(z10.string(), llmFulfillmentSchema)
+});
+
+// src/client/a2a/extensions/services/mcp/schemas.ts
+import z11 from "zod";
+
+// 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 = z11.enum(MCPTransportType);
+var mcpDemandSchema = z11.object({
+  description: z11.string().nullish(),
+  suggested: z11.array(z11.string()).nullish(),
+  allowed_transports: z11.array(mcpTransportTypeSchema).nullish()
+});
+var mcpDemandsSchema = z11.object({
+  mcp_demands: z11.record(z11.string(), mcpDemandSchema)
+});
+var mcpFulfillmentSchema = z11.object({
+  transport: z11.object({
+    type: mcpTransportTypeSchema,
+    url: z11.string(),
+    headers: z11.record(z11.string(), z11.string()).optional()
+  })
+});
+var mcpFulfillmentsSchema = z11.object({
+  mcp_fulfillments: z11.record(z11.string(), mcpFulfillmentSchema)
+});
+
+// src/client/a2a/extensions/services/platform-api/schemas.ts
+import z12 from "zod";
+var platformApiMetadataSchema = z12.object({
+  base_url: z12.string().nullish(),
+  auth_token: z12.string(),
+  expires_at: z12.string().nullish()
+});
+
+// src/client/a2a/extensions/ui/agent-detail/schemas.ts
+import z13 from "zod";
+
+// 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 = z13.enum(InteractionMode);
+var agentDetailToolSchema = z13.object({
+  name: z13.string(),
+  description: z13.string()
+});
+var agentDetailContributorSchema = z13.object({
+  name: z13.string(),
+  email: z13.string().nullish(),
+  url: z13.string().nullish()
+});
+var agentDetailSchema = z13.object({
+  interaction_mode: z13.union([interactionModeSchema, z13.string()]).nullish(),
+  user_greeting: z13.string().nullish(),
+  input_placeholder: z13.string().nullish(),
+  tools: z13.array(agentDetailToolSchema).nullish(),
+  framework: z13.string().nullish(),
+  license: z13.string().nullish(),
+  programming_language: z13.string().nullish(),
+  homepage_url: z13.string().nullish(),
+  source_code_url: z13.string().nullish(),
+  container_image_url: z13.string().nullish(),
+  author: agentDetailContributorSchema.nullish(),
+  contributors: z13.array(agentDetailContributorSchema).nullish()
+});
+
+// src/client/a2a/extensions/ui/canvas/schemas.ts
+import z14 from "zod";
+var canvasEditRequestSchema = z14.object({
+  start_index: z14.int(),
+  end_index: z14.int(),
+  description: z14.string().nullish(),
+  artifact_id: z14.string()
+});
+
+// src/client/a2a/extensions/ui/citation/schemas.ts
+import z15 from "zod";
+var citationSchema = z15.object({
+  url: z15.string().nullish(),
+  start_index: z15.number().nullish(),
+  end_index: z15.number().nullish(),
+  title: z15.string().nullish(),
+  description: z15.string().nullish()
+});
+var citationMetadataSchema = z15.object({
+  citations: z15.array(citationSchema)
+});
+
+// src/client/a2a/extensions/ui/error/schemas.ts
+import z16 from "zod";
+var errorSchema = z16.object({
+  title: z16.string(),
+  message: z16.string()
+});
+var errorGroupSchema = z16.object({
+  message: z16.string(),
+  errors: z16.array(errorSchema)
+});
+var errorMetadataSchema = z16.object({
+  error: z16.union([errorSchema, errorGroupSchema]),
+  context: z16.record(z16.string(), z16.unknown()).nullish(),
+  stack_trace: z16.string().nullish()
+});
+
+// src/client/a2a/extensions/ui/settings/schemas.ts
+import z17 from "zod";
+var settingsCheckboxFieldSchema = z17.object({
+  id: z17.string().nonempty(),
+  label: z17.string().nonempty(),
+  default_value: z17.boolean()
+});
+var settingsCheckboxGroupFieldSchema = z17.object({
+  id: z17.string().nonempty(),
+  type: z17.literal("checkbox_group"),
+  fields: z17.array(settingsCheckboxFieldSchema)
+});
+var settingsOptionItemSchema = z17.object({
+  label: z17.string().nonempty(),
+  value: z17.string().nonempty()
+});
+var settingsSingleSelectFieldSchema = z17.object({
+  type: z17.literal("single_select"),
+  id: z17.string().nonempty(),
+  label: z17.string().nonempty(),
+  options: z17.array(settingsOptionItemSchema).nonempty(),
+  default_value: z17.string().nonempty()
+});
+var settingsFieldSchema = z17.discriminatedUnion("type", [
+  settingsCheckboxGroupFieldSchema,
+  settingsSingleSelectFieldSchema
+]);
+var settingsCheckboxFieldValueSchema = z17.object({
+  value: z17.boolean()
+});
+var settingsCheckboxGroupFieldValueSchema = z17.object({
+  type: z17.literal("checkbox_group"),
+  values: z17.record(z17.string(), settingsCheckboxFieldValueSchema)
+});
+var settingsSingleSelectFieldValueSchema = z17.object({
+  type: z17.literal("single_select"),
+  value: z17.string()
+});
+var settingsFieldValueSchema = z17.discriminatedUnion("type", [
+  settingsCheckboxGroupFieldValueSchema,
+  settingsSingleSelectFieldValueSchema
+]);
+var settingsDemandsSchema = z17.object({
+  fields: z17.array(settingsFieldSchema)
+});
+var settingsValuesSchema = z17.record(z17.string(), settingsFieldValueSchema);
+var settingsFulfillmentsSchema = z17.object({
+  values: settingsValuesSchema
+});
+
+// src/client/a2a/extensions/ui/trajectory/schemas.ts
+import z18 from "zod";
+var trajectoryMetadataSchema = z18.object({
+  title: z18.string().nullish(),
+  content: z18.string().nullish(),
+  group_id: z18.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
+import z19 from "zod";
+var AGENT_DETAIL_EXTENSION_URI = "https://a2a-extensions.agentstack.beeai.dev/ui/agent-detail/v1";
+
+// src/client/a2a/extensions/ui/canvas/index.ts
+import z20 from "zod";
+
+// src/client/a2a/extensions/ui/citation/index.ts
+import z21 from "zod";
+
+// src/client/a2a/extensions/ui/error/index.ts
+import z22 from "zod";
+
+// src/client/a2a/extensions/ui/form-request/index.ts
+import z23 from "zod";
+
+// src/client/a2a/extensions/ui/trajectory/index.ts
+import z24 from "zod";
+
+// 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
+import z25 from "zod";
+var configSchema = z25.object({
+  platformUrl: z25.string().default("http://127.0.0.1:8333"),
+  productionMode: z25.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
+import { DefaultRequestHandler, InMemoryTaskStore } from "@a2a-js/sdk/server";
+import { agentCardHandler, jsonRpcHandler, UserBuilder } from "@a2a-js/sdk/server/express";
+import express from "express";
+
+// src/client/api/configuration/schemas.ts
+import z26 from "zod";
+var systemConfigurationSchema = z26.object({
+  id: z26.string(),
+  created_by: z26.string(),
+  updated_at: z26.string(),
+  default_embedding_model: z26.string().nullish(),
+  default_llm_model: z26.string().nullish()
+});
+var readSystemConfigurationRequestSchema = z26.never();
+var readSystemConfigurationResponseSchema = systemConfigurationSchema;
+var updateSystemConfigurationRequestSchema = z26.object({
+  default_embedding_model: z26.string().nullish(),
+  default_llm_model: z26.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
+import z28 from "zod";
+
+// src/client/api/core/schemas.ts
+import z27 from "zod";
+var paginationQuerySchema = z27.object({
+  limit: z27.number().optional(),
+  order: z27.string().optional(),
+  order_by: z27.string().optional(),
+  page_token: z27.string().nullish()
+});
+var paginatedResponseSchema = z27.object({
+  items: z27.array(z27.unknown()),
+  total_count: z27.number(),
+  has_more: z27.boolean(),
+  next_page_token: z27.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 = z28.enum(ConnectorState);
+var connectorSchema = z28.object({
+  id: z28.string(),
+  url: z28.string(),
+  state: connectorStateSchema,
+  auth_request: z28.object({
+    type: z28.literal("code"),
+    authorization_endpoint: z28.string()
+  }).nullable(),
+  disconnect_reason: z28.string().nullable(),
+  metadata: z28.record(z28.string(), z28.string()).nullable()
+});
+var listConnectorsRequestSchema = z28.never();
+var listConnectorsResponseSchema = paginatedResponseSchema.extend({
+  items: z28.array(connectorSchema)
+});
+var createConnectorRequestSchema = z28.object({
+  match_preset: z28.boolean(),
+  url: z28.string(),
+  client_id: z28.string().nullish(),
+  client_secret: z28.string().nullish(),
+  metadata: z28.record(z28.string(), z28.string()).nullish()
+});
+var createConnectorResponseSchema = connectorSchema;
+var readConnectorRequestSchema = z28.object({
+  connector_id: z28.string()
+});
+var readConnectorResponseSchema = connectorSchema;
+var deleteConnectorRequestSchema = z28.object({
+  connector_id: z28.string()
+});
+var deleteConnectorResponseSchema = z28.null();
+var connectConnectorRequestSchema = z28.object({
+  connector_id: z28.string(),
+  redirect_url: z28.string().nullish()
+});
+var connectConnectorResponseSchema = connectorSchema;
+var disconnectConnectorRequestSchema = z28.object({
+  connector_id: z28.string()
+});
+var disconnectConnectorResponseSchema = connectorSchema;
+var connectorPresetSchema = z28.object({
+  url: z28.string(),
+  metadata: z28.record(z28.string(), z28.string()).nullable()
+});
+var listConnectorPresetsRequestSchema = z28.never();
+var listConnectorPresetsResponseSchema = paginatedResponseSchema.extend({
+  items: z28.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
+import z31 from "zod";
+
+// src/client/a2a/protocol/schemas.ts
+import z30 from "zod";
+
+// src/client/a2a/protocol/utils.ts
+import z29 from "zod";
+function a2aSchema(schema) {
+  return z29.preprocess((value) => normalizeOptionalNulls(schema, value), schema);
+}
+function normalizeOptionalNulls(schema, data) {
+  if (schema instanceof z29.ZodOptional) {
+    if (data === null) {
+      return void 0;
+    }
+    return normalizeOptionalNulls(schema.unwrap(), data);
+  }
+  if (schema instanceof z29.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(
+  z30.object({
+    transport: z30.string(),
+    url: z30.string()
+  })
+);
+var agentExtensionSchema = a2aSchema(
+  z30.object({
+    uri: z30.string(),
+    description: z30.string().optional(),
+    required: z30.boolean().optional(),
+    params: z30.record(z30.string(), z30.unknown()).optional()
+  })
+);
+var agentCapabilitiesSchema = a2aSchema(
+  z30.object({
+    extensions: z30.array(agentExtensionSchema).optional(),
+    pushNotifications: z30.boolean().optional(),
+    stateTransitionHistory: z30.boolean().optional(),
+    streaming: z30.boolean().optional()
+  })
+);
+var agentProviderSchema = a2aSchema(
+  z30.object({
+    url: z30.string(),
+    organization: z30.string()
+  })
+);
+var agentCardSignatureSchema = a2aSchema(
+  z30.object({
+    signature: z30.string(),
+    protected: z30.string(),
+    header: z30.record(z30.string(), z30.unknown()).optional()
+  })
+);
+var agentSkillSchema = a2aSchema(
+  z30.object({
+    id: z30.string(),
+    name: z30.string(),
+    description: z30.string(),
+    tags: z30.array(z30.string()),
+    inputModes: z30.array(z30.string()).optional(),
+    outputModes: z30.array(z30.string()).optional(),
+    examples: z30.array(z30.string()).optional(),
+    security: z30.array(z30.record(z30.string(), z30.array(z30.string()))).optional()
+  })
+);
+var authorizationCodeOAuthFlowSchema = a2aSchema(
+  z30.object({
+    authorizationUrl: z30.string(),
+    tokenUrl: z30.string(),
+    scopes: z30.record(z30.string(), z30.string()),
+    refreshUrl: z30.string().optional()
+  })
+);
+var clientCredentialsOAuthFlowSchema = a2aSchema(
+  z30.object({
+    tokenUrl: z30.string(),
+    scopes: z30.record(z30.string(), z30.string()),
+    refreshUrl: z30.string().optional()
+  })
+);
+var implicitOAuthFlowSchema = a2aSchema(
+  z30.object({
+    authorizationUrl: z30.string(),
+    scopes: z30.record(z30.string(), z30.string()),
+    refreshUrl: z30.string().optional()
+  })
+);
+var passwordOAuthFlowSchema = a2aSchema(
+  z30.object({
+    tokenUrl: z30.string(),
+    scopes: z30.record(z30.string(), z30.string()),
+    refreshUrl: z30.string().optional()
+  })
+);
+var oauthFlowsSchema = a2aSchema(
+  z30.object({
+    authorizationCode: authorizationCodeOAuthFlowSchema.optional(),
+    clientCredentials: clientCredentialsOAuthFlowSchema.optional(),
+    implicit: implicitOAuthFlowSchema.optional(),
+    password: passwordOAuthFlowSchema.optional()
+  })
+);
+var apiKeySecuritySchemeSchema = a2aSchema(
+  z30.object({
+    type: z30.literal("apiKey"),
+    name: z30.string(),
+    in: z30.literal(["cookie", "header", "query"]),
+    description: z30.string().optional()
+  })
+);
+var httpAuthSecuritySchemeSchema = a2aSchema(
+  z30.object({
+    type: z30.literal("http"),
+    scheme: z30.string(),
+    description: z30.string().optional(),
+    bearerFormat: z30.string().optional()
+  })
+);
+var oauth2SecuritySchemeSchema = a2aSchema(
+  z30.object({
+    type: z30.literal("oauth2"),
+    flows: oauthFlowsSchema,
+    description: z30.string().optional(),
+    oauth2MetadataUrl: z30.string().optional()
+  })
+);
+var openIdConnectSecuritySchemeSchema = a2aSchema(
+  z30.object({
+    type: z30.literal("openIdConnect"),
+    openIdConnectUrl: z30.string(),
+    description: z30.string().optional()
+  })
+);
+var mutualTlsSecuritySchemeSchema = a2aSchema(
+  z30.object({
+    type: z30.literal("mutualTLS"),
+    description: z30.string().optional()
+  })
+);
+var securitySchemeSchema = a2aSchema(
+  z30.union([
+    apiKeySecuritySchemeSchema,
+    httpAuthSecuritySchemeSchema,
+    oauth2SecuritySchemeSchema,
+    openIdConnectSecuritySchemeSchema,
+    mutualTlsSecuritySchemeSchema
+  ])
+);
+var agentCardSchema = a2aSchema(
+  z30.object({
+    url: z30.string(),
+    name: z30.string(),
+    description: z30.string(),
+    version: z30.string(),
+    protocolVersion: z30.string(),
+    capabilities: agentCapabilitiesSchema,
+    defaultInputModes: z30.array(z30.string()),
+    defaultOutputModes: z30.array(z30.string()),
+    skills: z30.array(agentSkillSchema),
+    iconUrl: z30.string().optional(),
+    documentationUrl: z30.string().optional(),
+    preferredTransport: z30.string().optional(),
+    supportsAuthenticatedExtendedCard: z30.boolean().optional(),
+    additionalInterfaces: z30.array(agentInterfaceSchema).optional(),
+    provider: agentProviderSchema.optional(),
+    signatures: z30.array(agentCardSignatureSchema).optional(),
+    security: z30.array(z30.record(z30.string(), z30.array(z30.string()))).optional(),
+    securitySchemes: z30.record(z30.string(), securitySchemeSchema).optional()
+  })
+);
+var fileWithBytesSchema = a2aSchema(
+  z30.object({
+    bytes: z30.string(),
+    mimeType: z30.string().optional(),
+    name: z30.string().optional()
+  })
+);
+var fileWithUriSchema = a2aSchema(
+  z30.object({
+    uri: z30.string(),
+    mimeType: z30.string().optional(),
+    name: z30.string().optional()
+  })
+);
+var textPartSchema = a2aSchema(
+  z30.object({
+    kind: z30.literal("text"),
+    text: z30.string(),
+    metadata: z30.record(z30.string(), z30.unknown()).optional()
+  })
+);
+var filePartSchema = a2aSchema(
+  z30.object({
+    kind: z30.literal("file"),
+    file: z30.union([fileWithBytesSchema, fileWithUriSchema]),
+    metadata: z30.record(z30.string(), z30.unknown()).optional()
+  })
+);
+var dataPartSchema = a2aSchema(
+  z30.object({
+    kind: z30.literal("data"),
+    data: z30.record(z30.string(), z30.unknown()),
+    metadata: z30.record(z30.string(), z30.unknown()).optional()
+  })
+);
+var partSchema = a2aSchema(z30.union([textPartSchema, filePartSchema, dataPartSchema]));
+var artifactSchema = a2aSchema(
+  z30.object({
+    artifactId: z30.string(),
+    parts: z30.array(partSchema),
+    description: z30.string().optional(),
+    extensions: z30.array(z30.string()).optional(),
+    metadata: z30.record(z30.string(), z30.unknown()).optional(),
+    name: z30.string().optional()
+  })
+);
+var messageSchema = a2aSchema(
+  z30.object({
+    kind: z30.literal("message"),
+    messageId: z30.string(),
+    parts: z30.array(partSchema),
+    role: z30.literal(["agent", "user"]),
+    contextId: z30.string().optional(),
+    extensions: z30.array(z30.string()).optional(),
+    metadata: z30.record(z30.string(), z30.unknown()).optional(),
+    referenceTaskIds: z30.array(z30.string()).optional(),
+    taskId: z30.string().optional()
+  })
+);
+var taskStatusSchema = a2aSchema(
+  z30.object({
+    state: z30.literal([
+      "submitted",
+      "working",
+      "input-required",
+      "completed",
+      "canceled",
+      "failed",
+      "rejected",
+      "auth-required",
+      "unknown"
+    ]),
+    message: messageSchema.optional(),
+    timestamp: z30.string().optional()
+  })
+);
+var taskStatusUpdateEventSchema = a2aSchema(
+  z30.object({
+    kind: z30.literal("status-update"),
+    taskId: z30.string(),
+    contextId: z30.string(),
+    status: taskStatusSchema,
+    final: z30.boolean(),
+    metadata: z30.record(z30.string(), z30.unknown()).optional()
+  })
+);
+var taskSchema = a2aSchema(
+  z30.object({
+    kind: z30.literal("task"),
+    id: z30.string(),
+    contextId: z30.string(),
+    status: taskStatusSchema,
+    artifacts: z30.array(artifactSchema).optional(),
+    history: z30.array(messageSchema).optional(),
+    metadata: z30.record(z30.string(), z30.unknown()).optional()
+  })
+);
+var taskArtifactUpdateEventSchema = a2aSchema(
+  z30.object({
+    kind: z30.literal("artifact-update"),
+    taskId: z30.string(),
+    contextId: z30.string(),
+    artifact: artifactSchema,
+    append: z30.boolean().optional(),
+    lastChunk: z30.boolean().optional(),
+    metadata: z30.record(z30.string(), z30.unknown()).optional()
+  })
+);
+var errorBaseSchema = z30.object({
+  message: z30.string(),
+  data: z30.record(z30.string(), z30.unknown()).optional()
+});
+var jsonRpcErrorSchema = a2aSchema(
+  errorBaseSchema.extend({
+    code: z30.number()
+  })
+);
+var jsonParseErrorSchema = a2aSchema(
+  errorBaseSchema.extend({
+    code: z30.literal(-32700)
+  })
+);
+var invalidRequestErrorSchema = a2aSchema(
+  errorBaseSchema.extend({
+    code: z30.literal(-32600)
+  })
+);
+var methodNotFoundErrorSchema = a2aSchema(
+  errorBaseSchema.extend({
+    code: z30.literal(-32601)
+  })
+);
+var invalidParamsErrorSchema = a2aSchema(
+  errorBaseSchema.extend({
+    code: z30.literal(-32602)
+  })
+);
+var internalErrorSchema = a2aSchema(
+  errorBaseSchema.extend({
+    code: z30.literal(-32603)
+  })
+);
+var taskNotFoundErrorSchema = a2aSchema(
+  errorBaseSchema.extend({
+    code: z30.literal(-32001)
+  })
+);
+var taskNotCancelableErrorSchema = a2aSchema(
+  errorBaseSchema.extend({
+    code: z30.literal(-32002)
+  })
+);
+var pushNotificationNotSupportedErrorSchema = a2aSchema(
+  errorBaseSchema.extend({
+    code: z30.literal(-32003)
+  })
+);
+var unsupportedOperationErrorSchema = a2aSchema(
+  errorBaseSchema.extend({
+    code: z30.literal(-32004)
+  })
+);
+var contentTypeNotSupportedErrorSchema = a2aSchema(
+  errorBaseSchema.extend({
+    code: z30.literal(-32005)
+  })
+);
+var invalidAgentResponseErrorSchema = a2aSchema(
+  errorBaseSchema.extend({
+    code: z30.literal(-32006)
+  })
+);
+var authenticatedExtendedCardNotConfiguredErrorSchema = a2aSchema(
+  errorBaseSchema.extend({
+    code: z30.literal(-32007)
+  })
+);
+var jsonRpcErrorResponseSchema = a2aSchema(
+  z30.object({
+    jsonrpc: z30.literal("2.0"),
+    id: z30.union([z30.string(), z30.number()]).nullable(),
+    error: z30.union([
+      jsonRpcErrorSchema,
+      jsonParseErrorSchema,
+      invalidRequestErrorSchema,
+      methodNotFoundErrorSchema,
+      invalidParamsErrorSchema,
+      internalErrorSchema,
+      taskNotFoundErrorSchema,
+      taskNotCancelableErrorSchema,
+      pushNotificationNotSupportedErrorSchema,
+      unsupportedOperationErrorSchema,
+      contentTypeNotSupportedErrorSchema,
+      invalidAgentResponseErrorSchema,
+      authenticatedExtendedCardNotConfiguredErrorSchema
+    ])
+  })
+);
+var getTaskSuccessResponseSchema = a2aSchema(
+  z30.object({
+    jsonrpc: z30.literal("2.0"),
+    id: z30.union([z30.string(), z30.number()]).nullable(),
+    result: taskSchema
+  })
+);
+var getTaskResponseSchema = a2aSchema(z30.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 = z31.object({
+  id: z31.string(),
+  created_at: z31.string(),
+  updated_at: z31.string(),
+  last_active_at: z31.string(),
+  created_by: z31.string(),
+  provider_id: z31.string().nullable(),
+  metadata: z31.record(z31.string(), z31.unknown()).nullable()
+});
+var listContextsRequestSchema = z31.object({
+  query: paginationQuerySchema.extend({
+    provider_id: z31.string().nullish(),
+    include_empty: z31.boolean().optional()
+  }).optional()
+});
+var listContextsResponseSchema = paginatedResponseSchema.extend({
+  items: z31.array(contextSchema)
+});
+var createContextRequestSchema = z31.object({
+  provider_id: z31.string().nullish(),
+  metadata: z31.record(z31.string(), z31.string()).nullish()
+});
+var createContextResponseSchema = contextSchema;
+var readContextRequestSchema = z31.object({
+  context_id: z31.string()
+});
+var readContextResponseSchema = contextSchema;
+var updateContextRequestSchema = z31.object({
+  context_id: z31.string(),
+  metadata: z31.record(z31.string(), z31.string()).nullish()
+});
+var updateContextResponseSchema = contextSchema;
+var deleteContextRequestSchema = z31.object({
+  context_id: z31.string()
+});
+var deleteContextResponseSchema = z31.null();
+var contextHistoryKind = z31.enum(ContextHistoryKind);
+var contextHistorySchema = z31.object({
+  id: z31.string(),
+  context_id: z31.string(),
+  created_at: z31.string(),
+  kind: contextHistoryKind,
+  data: z31.union([artifactSchema, messageSchema])
+});
+var listContextHistoryRequestSchema = z31.object({
+  context_id: z31.string(),
+  query: paginationQuerySchema.optional()
+});
+var listContextHistoryResponseSchema = paginatedResponseSchema.extend({
+  items: z31.array(contextHistorySchema)
+});
+var createContextHistoryRequestSchema = z31.object({
+  context_id: z31.string(),
+  data: z31.union([artifactSchema, messageSchema])
+});
+var createContextHistoryResponseSchema = z31.null();
+var patchContextMetadataRequestSchema = z31.object({
+  context_id: z31.string(),
+  metadata: z31.record(z31.string(), z31.union([z31.string(), z31.null()]))
+});
+var patchContextMetadataResponseSchema = contextSchema;
+var contextTokenSchema = z31.object({
+  token: z31.string(),
+  expires_at: z31.string().nullable()
+});
+var resourceIdPermissionSchema = z31.object({
+  id: z31.string()
+});
+var contextPermissionsGrantSchema = z31.object({
+  files: z31.array(z31.literal(["read", "write", "extract", "*"])).optional(),
+  vector_stores: z31.array(z31.literal(["read", "write", "*"])).optional(),
+  context_data: z31.array(z31.literal(["read", "write", "*"])).optional()
+});
+var globalPermissionsGrantSchema = contextPermissionsGrantSchema.extend({
+  feedback: z31.array(z31.literal("write")).optional(),
+  llm: z31.array(z31.union([z31.literal("*"), resourceIdPermissionSchema])).optional(),
+  embeddings: z31.array(z31.union([z31.literal("*"), resourceIdPermissionSchema])).optional(),
+  model_providers: z31.array(z31.literal(["read", "write", "*"])).optional(),
+  a2a_proxy: z31.array(z31.union([z31.literal("*"), z31.string()])).optional(),
+  providers: z31.array(z31.literal(["read", "write", "*"])).optional(),
+  provider_variables: z31.array(z31.literal(["read", "write", "*"])).optional(),
+  contexts: z31.array(z31.literal(["read", "write", "*"])).optional(),
+  connectors: z31.array(z31.literal(["read", "write", "proxy", "*"])).optional()
+}).superRefine((val, ctx) => {
+  if (!val.a2a_proxy) return;
+  if (val.a2a_proxy.length === 0) {
+    ctx.addIssue({
+      code: z31.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: z31.ZodIssueCode.custom,
+      message: "a2a_proxy cannot mix '*' with specific providers",
+      path: ["a2a_proxy"]
+    });
+  }
+});
+var createContextTokenRequestSchema = z31.object({
+  context_id: z31.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
+import z32 from "zod";
+
+// 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 = z32.enum(FileType);
+var fileSchema = z32.object({
+  id: z32.string(),
+  filename: z32.string(),
+  content_type: z32.string(),
+  file_type: fileTypeSchema,
+  created_by: z32.string(),
+  created_at: z32.string(),
+  context_id: z32.string().nullish(),
+  file_size_bytes: z32.number().nullish(),
+  parent_file_id: z32.string().nullish()
+});
+var createFileRequestSchema = z32.object({
+  context_id: z32.string().nullable(),
+  file: z32.union([
+    z32.file(),
+    z32.object({
+      blob: z32.instanceof(Blob),
+      filename: z32.string()
+    })
+  ])
+});
+var createFileResponseSchema = fileSchema;
+var readFileRequestSchema = z32.object({
+  context_id: z32.string().nullable(),
+  file_id: z32.string()
+});
+var readFileResponseSchema = fileSchema;
+var deleteFileRequestSchema = z32.object({
+  context_id: z32.string().nullable(),
+  file_id: z32.string()
+});
+var deleteFileResponseSchema = z32.null();
+var readFileContentRequestSchema = z32.object({
+  context_id: z32.string().nullable(),
+  file_id: z32.string()
+});
+var readFileContentResponseSchema = z32.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
+import z33 from "zod";
+
+// 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 = z33.enum(ModelCapability);
+var modelProviderTypeSchema = z33.enum(ModelProviderType);
+var modelProviderSchema = z33.object({
+  id: z33.string(),
+  base_url: z33.string(),
+  created_at: z33.string(),
+  capabilities: z33.array(modelCapabilitySchema),
+  name: z33.string().nullish(),
+  description: z33.string().nullish(),
+  type: modelProviderTypeSchema
+});
+var listModelProvidersRequestSchema = z33.never();
+var listModelProvidersResponseSchema = paginatedResponseSchema.extend({
+  items: z33.array(modelProviderSchema)
+});
+var createModelProviderRequestSchema = z33.object({
+  api_key: z33.string(),
+  base_url: z33.string(),
+  type: modelProviderTypeSchema,
+  name: z33.string().nullish(),
+  description: z33.string().nullish(),
+  watsonx_project_id: z33.string().nullish(),
+  watsonx_space_id: z33.string().nullish()
+});
+var createModelProviderResponseSchema = modelProviderSchema;
+var readModelProviderRequestSchema = z33.object({
+  model_provider_id: z33.string()
+});
+var readModelProviderResponseSchema = modelProviderSchema;
+var deleteModelProviderRequestSchema = z33.object({
+  model_provider_id: z33.string()
+});
+var deleteModelProviderResponseSchema = z33.null();
+var matchModelProvidersRequestSchema = z33.object({
+  suggested_models: z33.array(z33.string()).nullable(),
+  capability: modelCapabilitySchema,
+  score_cutoff: z33.number()
+});
+var matchModelProvidersResponseSchema = paginatedResponseSchema.extend({
+  items: z33.array(
+    z33.object({
+      model_id: z33.string(),
+      score: z33.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
+import z35 from "zod";
+
+// src/client/api/common/schemas.ts
+import z34 from "zod";
+
+// 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 = z34.enum(GitHubVersionType);
+var gitHubRegistryLocationSchema = z34.string();
+var networkRegistryLocationSchema = z34.string();
+var fileSystemRegistryLocationSchema = z34.string();
+var dockerImageIdSchema = z34.string();
+var dockerImageProviderLocationSchema = dockerImageIdSchema;
+var networkProviderLocationSchema = z34.string();
+var resolvedGitHubUrlSchema = z34.object({
+  host: z34.string(),
+  org: z34.string(),
+  repo: z34.string(),
+  version: z34.string(),
+  version_type: gitHubVersionTypeSchema,
+  commit_hash: z34.string(),
+  path: z34.string().nullish()
+});
+var resolvedDockerImageIdSchema = z34.object({
+  registry: z34.string(),
+  repository: z34.string(),
+  tag: z34.string(),
+  digest: z34.string(),
+  image_id: dockerImageIdSchema
+});
+var readableStreamSchema = z34.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 = z35.enum(ProviderBuildState);
+var providerBuildAddActionSchema = z35.object({
+  type: z35.literal("add_provider"),
+  auto_stop_timeout_sec: z35.number().nullish(),
+  variables: z35.record(z35.string(), z35.string()).nullish()
+});
+var providerBuildUpdateActionSchema = z35.object({
+  type: z35.literal("update_provider"),
+  provider_id: z35.string()
+});
+var providerBuildNoActionSchema = z35.object({
+  type: z35.literal("no_action")
+});
+var providerBuildOnCompleteActionSchema = z35.union([
+  providerBuildAddActionSchema,
+  providerBuildUpdateActionSchema,
+  providerBuildNoActionSchema
+]);
+var providerBuildConfigurationSchema = z35.object({
+  dockerfile_path: z35.string().nullish()
+});
+var providerBuildSchema = z35.object({
+  id: z35.string(),
+  created_at: z35.string(),
+  created_by: z35.string(),
+  provider_origin: z35.string(),
+  status: providerBuildStateSchema,
+  source: resolvedGitHubUrlSchema,
+  destination: dockerImageIdSchema,
+  on_complete: providerBuildOnCompleteActionSchema,
+  build_configuration: providerBuildConfigurationSchema.nullish(),
+  provider_id: z35.string().nullish(),
+  error_message: z35.string().nullish()
+});
+var listProviderBuildsRequestSchema = z35.object({
+  query: paginationQuerySchema.extend({
+    status: providerBuildStateSchema.nullish(),
+    user_owned: z35.boolean().nullish()
+  }).optional()
+});
+var listProviderBuildsResponseSchema = paginatedResponseSchema.extend({
+  items: z35.array(providerBuildSchema)
+});
+var createProviderBuildRequestSchema = z35.object({
+  location: z35.string(),
+  build_configuration: providerBuildConfigurationSchema.nullish(),
+  on_complete: providerBuildOnCompleteActionSchema.optional()
+});
+var createProviderBuildResponseSchema = providerBuildSchema;
+var readProviderBuildRequestSchema = z35.object({
+  id: z35.string()
+});
+var readProviderBuildResponseSchema = providerBuildSchema;
+var deleteProviderBuildRequestSchema = z35.object({
+  id: z35.string()
+});
+var deleteProviderBuildResponseSchema = z35.null();
+var readProviderBuildLogsRequestSchema = z35.object({
+  id: z35.string()
+});
+var readProviderBuildLogsResponseSchema = readableStreamSchema;
+var previewProviderBuildRequestSchema = z35.object({
+  location: z35.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
+import z36 from "zod";
+
+// 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 = z36.enum(ProviderType);
+var providerStatusSchema = z36.enum(ProviderStatus);
+var providerUnmanagedStatusSchema = z36.enum(ProviderUnmanagedStatus);
+var providerErrorSchema = z36.object({
+  message: z36.string()
+});
+var providerEnvVarSchema = z36.object({
+  name: z36.string(),
+  required: z36.boolean(),
+  description: z36.string().nullish()
+});
+var providerVersionInfoSchema = z36.object({
+  docker: resolvedDockerImageIdSchema.nullish(),
+  github: resolvedGitHubUrlSchema.nullish()
+});
+var providerSchema = z36.object({
+  id: z36.string(),
+  source: z36.union([dockerImageProviderLocationSchema, networkProviderLocationSchema]),
+  agent_card: agentCardSchema,
+  state: z36.union([providerStatusSchema, providerUnmanagedStatusSchema]),
+  origin: z36.string(),
+  created_at: z36.string(),
+  created_by: z36.string(),
+  updated_at: z36.string(),
+  last_active_at: z36.string(),
+  auto_stop_timeout: z36.string(),
+  managed: z36.boolean(),
+  type: providerTypeSchema,
+  env: z36.array(providerEnvVarSchema),
+  registry: z36.union([gitHubRegistryLocationSchema, networkRegistryLocationSchema, fileSystemRegistryLocationSchema]).nullish(),
+  last_error: providerErrorSchema.nullish(),
+  missing_configuration: z36.array(providerEnvVarSchema).optional(),
+  version_info: providerVersionInfoSchema.optional()
+});
+var listProvidersRequestSchema = z36.object({
+  query: z36.object({
+    origin: z36.string().nullish(),
+    user_owned: z36.boolean().nullish()
+  }).optional()
+});
+var listProvidersResponseSchema = paginatedResponseSchema.extend({
+  items: z36.array(providerSchema)
+});
+var createProviderRequestSchema = z36.object({
+  location: z36.union([dockerImageProviderLocationSchema, networkProviderLocationSchema]),
+  agent_card: agentCardSchema.nullish(),
+  auto_stop_timeout_sec: z36.number().nullish(),
+  origin: z36.string().nullish(),
+  variables: z36.record(z36.string(), z36.string()).nullish()
+});
+var createProviderResponseSchema = providerSchema;
+var readProviderRequestSchema = z36.object({
+  id: z36.string()
+});
+var readProviderResponseSchema = providerSchema;
+var deleteProviderRequestSchema = z36.object({
+  id: z36.string()
+});
+var deleteProviderResponseSchema = z36.null();
+var patchProviderRequestSchema = z36.object({
+  id: z36.string(),
+  location: z36.union([dockerImageProviderLocationSchema, networkProviderLocationSchema]).nullish(),
+  agent_card: agentCardSchema.nullish(),
+  auto_stop_timeout_sec: z36.number().nullish(),
+  origin: z36.string().nullish(),
+  variables: z36.record(z36.string(), z36.string()).nullish()
+});
+var patchProviderResponseSchema = providerSchema;
+var readProviderLogsRequestSchema = z36.object({
+  id: z36.string()
+});
+var readProviderLogsResponseSchema = readableStreamSchema;
+var listProviderVariablesRequestSchema = z36.object({
+  id: z36.string()
+});
+var listProviderVariablesResponseSchema = z36.object({
+  variables: z36.record(z36.string(), z36.string())
+});
+var updateProviderVariablesRequestSchema = z36.object({
+  id: z36.string(),
+  variables: z36.record(z36.string(), z36.union([z36.string(), z36.null()]))
+});
+var updateProviderVariablesResponseSchema = z36.null();
+var readProviderByLocationRequestSchema = z36.object({
+  location: z36.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
+import z37 from "zod";
+var createUserFeedbackRequestSchema = z37.object({
+  provider_id: z37.string(),
+  context_id: z37.string(),
+  task_id: z37.string(),
+  message: z37.string(),
+  rating: z37.union([z37.literal(1), z37.literal(-1)]),
+  comment: z37.string().nullish(),
+  comment_tags: z37.array(z37.string()).nullish()
+});
+var createUserFeedbackResponseSchema = z37.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
+import z38 from "zod";
+
+// 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 = z38.enum(UserRole);
+var userSchema = z38.object({
+  id: z38.string(),
+  role: userRoleSchema,
+  email: z38.string(),
+  created_at: z38.string()
+});
+var readUserRequestSchema = z38.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
+import z39 from "zod";
+var listVariablesRequestSchema = z39.never();
+var listVariablesResponseSchema = z39.object({
+  variables: z39.record(z39.string(), z39.string())
+});
+var updateVariablesRequestSchema = z39.object({
+  variables: z39.record(z39.string(), z39.union([z39.string(), z39.null()]))
+});
+var updateVariablesResponseSchema = z39.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
+import { randomUUID } from "crypto";
+function createMessage({
+  taskId,
+  contextId,
+  parts,
+  metadata
+}) {
+  return {
+    kind: "message",
+    messageId: 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 InMemoryTaskStore();
+    const executor = new AgentExecutorImpl(this.agentOptions.handler, this.agentOptions.extensions);
+    const requestHandler = new DefaultRequestHandler(this.agentCard, taskStore, executor);
+    const app = express();
+    const agentCardPath = `/.well-known/agent-card.json`;
+    app.use(jsonRpcHandler({ requestHandler, userBuilder: UserBuilder.noAuthentication }));
+    app.use(agentCardPath, 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;
+  }
+};
+export {
+  AgentDetailExtensionSpec,
+  LLMExtensionServer,
+  LLMExtensionSpec,
+  PLATFORM_SELF_REGISTRATION_EXTENSION_URI,
+  PlatformSelfRegistrationExtensionSpec,
+  RunContext,
+  Server,
+  configSchema,
+  isProductionMode,
+  loadConfig
+};