@inkeep/agents-core 0.35.1 → 0.35.3

package/dist/client-exports.cjs

@@ -1,2833 +0,0 @@
-'use strict';
-
-var zod = require('zod');
-var zodOpenapi = require('@hono/zod-openapi');
-var drizzleOrm = require('drizzle-orm');
-var pgCore = require('drizzle-orm/pg-core');
-var drizzleZod = require('drizzle-zod');
-var Ajv = require('ajv');
-var auth_js = require('@modelcontextprotocol/sdk/client/auth.js');
-
-function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
-
-var Ajv__default = /*#__PURE__*/_interopDefault(Ajv);
-
-// src/client-exports.ts
-
-// src/constants/schema-validation/defaults.ts
-var schemaValidationDefaults = {
-  // Agent Execution Transfer Count
-  // Controls how many times an agent can transfer control to sub-agents in a single conversation turn.
-  // This prevents infinite transfer loops while allowing multi-agent collaboration workflows.
-  AGENT_EXECUTION_TRANSFER_COUNT_MIN: 1,
-  AGENT_EXECUTION_TRANSFER_COUNT_MAX: 1e3,
-  // Sub-Agent Turn Generation Steps
-  // Limits how many AI generation steps a sub-agent can perform within a single turn.
-  // Each generation step typically involves sending a prompt to the LLM and processing its response.
-  // This prevents runaway token usage while allowing complex multi-step reasoning.
-  SUB_AGENT_TURN_GENERATION_STEPS_MIN: 1,
-  SUB_AGENT_TURN_GENERATION_STEPS_MAX: 1e3,
-  // Status Update Thresholds
-  // Real-time status updates are triggered when either threshold is exceeded during longer operations.
-  // MAX_NUM_EVENTS: Maximum number of internal events before forcing a status update to the client.
-  // MAX_INTERVAL_SECONDS: Maximum time between status updates regardless of event count.
-  STATUS_UPDATE_MAX_NUM_EVENTS: 100,
-  STATUS_UPDATE_MAX_INTERVAL_SECONDS: 600,
-  // 10 minutes
-  // Prompt Text Length Validation
-  // Maximum character limits for agent and sub-agent system prompts to prevent excessive token usage.
-  // Enforced during agent configuration to ensure prompts remain focused and manageable.
-  VALIDATION_SUB_AGENT_PROMPT_MAX_CHARS: 2e3,
-  VALIDATION_AGENT_PROMPT_MAX_CHARS: 5e3,
-  // Context Fetcher HTTP Timeout
-  // Maximum time allowed for HTTP requests made by Context Fetchers (e.g., CRM lookups, external API calls).
-  // Context Fetchers automatically retrieve external data at the start of a conversation to enrich agent context.
-  CONTEXT_FETCHER_HTTP_TIMEOUT_MS_DEFAULT: 1e4
-  // 10 seconds
-};
-
-// src/types/utility.ts
-var TOOL_STATUS_VALUES = ["healthy", "unhealthy", "unknown", "needs_auth"];
-var VALID_RELATION_TYPES = ["transfer", "delegate"];
-var MCPTransportType = {
-  streamableHttp: "streamable_http",
-  sse: "sse"
-};
-var MCPServerType = {
-  nango: "nango",
-  generic: "generic"
-};
-var CredentialStoreType = {
-  memory: "memory",
-  keychain: "keychain",
-  nango: "nango"
-};
-var user = pgCore.pgTable("user", {
-  id: pgCore.text("id").primaryKey(),
-  name: pgCore.text("name").notNull(),
-  email: pgCore.text("email").notNull().unique(),
-  emailVerified: pgCore.boolean("email_verified").default(false).notNull(),
-  image: pgCore.text("image"),
-  createdAt: pgCore.timestamp("created_at").defaultNow().notNull(),
-  updatedAt: pgCore.timestamp("updated_at").defaultNow().$onUpdate(() => /* @__PURE__ */ new Date()).notNull()
-});
-pgCore.pgTable("session", {
-  id: pgCore.text("id").primaryKey(),
-  expiresAt: pgCore.timestamp("expires_at").notNull(),
-  token: pgCore.text("token").notNull().unique(),
-  createdAt: pgCore.timestamp("created_at").defaultNow().notNull(),
-  updatedAt: pgCore.timestamp("updated_at").$onUpdate(() => /* @__PURE__ */ new Date()).notNull(),
-  ipAddress: pgCore.text("ip_address"),
-  userAgent: pgCore.text("user_agent"),
-  userId: pgCore.text("user_id").notNull().references(() => user.id, { onDelete: "cascade" }),
-  activeOrganizationId: pgCore.text("active_organization_id")
-});
-pgCore.pgTable("account", {
-  id: pgCore.text("id").primaryKey(),
-  accountId: pgCore.text("account_id").notNull(),
-  providerId: pgCore.text("provider_id").notNull(),
-  userId: pgCore.text("user_id").notNull().references(() => user.id, { onDelete: "cascade" }),
-  accessToken: pgCore.text("access_token"),
-  refreshToken: pgCore.text("refresh_token"),
-  idToken: pgCore.text("id_token"),
-  accessTokenExpiresAt: pgCore.timestamp("access_token_expires_at"),
-  refreshTokenExpiresAt: pgCore.timestamp("refresh_token_expires_at"),
-  scope: pgCore.text("scope"),
-  password: pgCore.text("password"),
-  createdAt: pgCore.timestamp("created_at").defaultNow().notNull(),
-  updatedAt: pgCore.timestamp("updated_at").$onUpdate(() => /* @__PURE__ */ new Date()).notNull()
-});
-pgCore.pgTable("verification", {
-  id: pgCore.text("id").primaryKey(),
-  identifier: pgCore.text("identifier").notNull(),
-  value: pgCore.text("value").notNull(),
-  expiresAt: pgCore.timestamp("expires_at").notNull(),
-  createdAt: pgCore.timestamp("created_at").defaultNow().notNull(),
-  updatedAt: pgCore.timestamp("updated_at").defaultNow().$onUpdate(() => /* @__PURE__ */ new Date()).notNull()
-});
-pgCore.pgTable("sso_provider", {
-  id: pgCore.text("id").primaryKey(),
-  issuer: pgCore.text("issuer").notNull(),
-  oidcConfig: pgCore.text("oidc_config"),
-  samlConfig: pgCore.text("saml_config"),
-  userId: pgCore.text("user_id").references(() => user.id, { onDelete: "cascade" }),
-  providerId: pgCore.text("provider_id").notNull().unique(),
-  organizationId: pgCore.text("organization_id"),
-  domain: pgCore.text("domain").notNull()
-});
-var organization = pgCore.pgTable("organization", {
-  id: pgCore.text("id").primaryKey(),
-  name: pgCore.text("name").notNull(),
-  slug: pgCore.text("slug").notNull().unique(),
-  logo: pgCore.text("logo"),
-  createdAt: pgCore.timestamp("created_at").notNull(),
-  metadata: pgCore.text("metadata")
-});
-pgCore.pgTable("member", {
-  id: pgCore.text("id").primaryKey(),
-  organizationId: pgCore.text("organization_id").notNull().references(() => organization.id, { onDelete: "cascade" }),
-  userId: pgCore.text("user_id").notNull().references(() => user.id, { onDelete: "cascade" }),
-  role: pgCore.text("role").default("member").notNull(),
-  createdAt: pgCore.timestamp("created_at").notNull()
-});
-pgCore.pgTable("invitation", {
-  id: pgCore.text("id").primaryKey(),
-  organizationId: pgCore.text("organization_id").notNull().references(() => organization.id, { onDelete: "cascade" }),
-  email: pgCore.text("email").notNull(),
-  role: pgCore.text("role"),
-  status: pgCore.text("status").default("pending").notNull(),
-  expiresAt: pgCore.timestamp("expires_at").notNull(),
-  inviterId: pgCore.text("inviter_id").notNull().references(() => user.id, { onDelete: "cascade" })
-});
-
-// src/db/schema.ts
-var tenantScoped = {
-  tenantId: pgCore.varchar("tenant_id", { length: 256 }).notNull(),
-  id: pgCore.varchar("id", { length: 256 }).notNull()
-};
-var projectScoped = {
-  ...tenantScoped,
-  projectId: pgCore.varchar("project_id", { length: 256 }).notNull()
-};
-var agentScoped = {
-  ...projectScoped,
-  agentId: pgCore.varchar("agent_id", { length: 256 }).notNull()
-};
-var subAgentScoped = {
-  ...agentScoped,
-  subAgentId: pgCore.varchar("sub_agent_id", { length: 256 }).notNull()
-};
-var uiProperties = {
-  name: pgCore.varchar("name", { length: 256 }).notNull(),
-  description: pgCore.text("description").notNull()
-};
-var timestamps = {
-  createdAt: pgCore.timestamp("created_at", { mode: "string" }).notNull().defaultNow(),
-  updatedAt: pgCore.timestamp("updated_at", { mode: "string" }).notNull().defaultNow()
-};
-var projects = pgCore.pgTable(
-  "projects",
-  {
-    ...tenantScoped,
-    ...uiProperties,
-    models: pgCore.jsonb("models").$type(),
-    stopWhen: pgCore.jsonb("stop_when").$type(),
-    ...timestamps
-  },
-  (table) => [
-    pgCore.primaryKey({ columns: [table.tenantId, table.id] }),
-    pgCore.foreignKey({
-      columns: [table.tenantId],
-      foreignColumns: [organization.id],
-      name: "projects_tenant_id_fk"
-    }).onDelete("cascade")
-  ]
-);
-var agents = pgCore.pgTable(
-  "agent",
-  {
-    ...projectScoped,
-    name: pgCore.varchar("name", { length: 256 }).notNull(),
-    description: pgCore.text("description"),
-    defaultSubAgentId: pgCore.varchar("default_sub_agent_id", { length: 256 }),
-    contextConfigId: pgCore.varchar("context_config_id", { length: 256 }),
-    models: pgCore.jsonb("models").$type(),
-    statusUpdates: pgCore.jsonb("status_updates").$type(),
-    prompt: pgCore.text("prompt"),
-    stopWhen: pgCore.jsonb("stop_when").$type(),
-    ...timestamps
-  },
-  (table) => [
-    pgCore.primaryKey({ columns: [table.tenantId, table.projectId, table.id] }),
-    pgCore.foreignKey({
-      columns: [table.tenantId, table.projectId],
-      foreignColumns: [projects.tenantId, projects.id],
-      name: "agent_project_fk"
-    }).onDelete("cascade")
-  ]
-);
-var contextConfigs = pgCore.pgTable(
-  "context_configs",
-  {
-    ...agentScoped,
-    headersSchema: pgCore.jsonb("headers_schema").$type(),
-    contextVariables: pgCore.jsonb("context_variables").$type(),
-    ...timestamps
-  },
-  (table) => [
-    pgCore.primaryKey({ columns: [table.tenantId, table.projectId, table.agentId, table.id] }),
-    pgCore.foreignKey({
-      columns: [table.tenantId, table.projectId, table.agentId],
-      foreignColumns: [agents.tenantId, agents.projectId, agents.id],
-      name: "context_configs_agent_fk"
-    }).onDelete("cascade")
-  ]
-);
-var contextCache = pgCore.pgTable(
-  "context_cache",
-  {
-    ...projectScoped,
-    conversationId: pgCore.varchar("conversation_id", { length: 256 }).notNull(),
-    contextConfigId: pgCore.varchar("context_config_id", { length: 256 }).notNull(),
-    contextVariableKey: pgCore.varchar("context_variable_key", { length: 256 }).notNull(),
-    value: pgCore.jsonb("value").$type().notNull(),
-    requestHash: pgCore.varchar("request_hash", { length: 256 }),
-    fetchedAt: pgCore.timestamp("fetched_at", { mode: "string" }).notNull().defaultNow(),
-    fetchSource: pgCore.varchar("fetch_source", { length: 256 }),
-    fetchDurationMs: pgCore.integer("fetch_duration_ms"),
-    ...timestamps
-  },
-  (table) => [
-    pgCore.primaryKey({ columns: [table.tenantId, table.projectId, table.id] }),
-    pgCore.foreignKey({
-      columns: [table.tenantId, table.projectId],
-      foreignColumns: [projects.tenantId, projects.id],
-      name: "context_cache_project_fk"
-    }).onDelete("cascade"),
-    pgCore.index("context_cache_lookup_idx").on(
-      table.conversationId,
-      table.contextConfigId,
-      table.contextVariableKey
-    )
-  ]
-);
-var subAgents = pgCore.pgTable(
-  "sub_agents",
-  {
-    ...agentScoped,
-    ...uiProperties,
-    prompt: pgCore.text("prompt").notNull(),
-    conversationHistoryConfig: pgCore.jsonb("conversation_history_config").$type().default({
-      mode: "full",
-      limit: 50,
-      maxOutputTokens: 4e3,
-      includeInternal: false,
-      messageTypes: ["chat", "tool-result"]
-    }),
-    models: pgCore.jsonb("models").$type(),
-    stopWhen: pgCore.jsonb("stop_when").$type(),
-    ...timestamps
-  },
-  (table) => [
-    pgCore.primaryKey({ columns: [table.tenantId, table.projectId, table.agentId, table.id] }),
-    pgCore.foreignKey({
-      columns: [table.tenantId, table.projectId, table.agentId],
-      foreignColumns: [agents.tenantId, agents.projectId, agents.id],
-      name: "sub_agents_agents_fk"
-    }).onDelete("cascade")
-  ]
-);
-var subAgentRelations = pgCore.pgTable(
-  "sub_agent_relations",
-  {
-    ...agentScoped,
-    sourceSubAgentId: pgCore.varchar("source_sub_agent_id", { length: 256 }).notNull(),
-    targetSubAgentId: pgCore.varchar("target_sub_agent_id", { length: 256 }),
-    relationType: pgCore.varchar("relation_type", { length: 256 }),
-    ...timestamps
-  },
-  (table) => [
-    pgCore.primaryKey({ columns: [table.tenantId, table.projectId, table.agentId, table.id] }),
-    pgCore.foreignKey({
-      columns: [table.tenantId, table.projectId, table.agentId],
-      foreignColumns: [agents.tenantId, agents.projectId, agents.id],
-      name: "sub_agent_relations_agent_fk"
-    }).onDelete("cascade")
-  ]
-);
-var externalAgents = pgCore.pgTable(
-  "external_agents",
-  {
-    ...projectScoped,
-    ...uiProperties,
-    baseUrl: pgCore.text("base_url").notNull(),
-    credentialReferenceId: pgCore.varchar("credential_reference_id", { length: 256 }),
-    ...timestamps
-  },
-  (table) => [
-    pgCore.primaryKey({ columns: [table.tenantId, table.projectId, table.id] }),
-    pgCore.foreignKey({
-      columns: [table.tenantId, table.projectId],
-      foreignColumns: [projects.tenantId, projects.id],
-      name: "external_agents_project_fk"
-    }).onDelete("cascade"),
-    pgCore.foreignKey({
-      columns: [table.tenantId, table.projectId, table.credentialReferenceId],
-      foreignColumns: [
-        credentialReferences.tenantId,
-        credentialReferences.projectId,
-        credentialReferences.id
-      ],
-      name: "external_agents_credential_reference_fk"
-    }).onDelete("cascade")
-  ]
-);
-var tasks = pgCore.pgTable(
-  "tasks",
-  {
-    ...subAgentScoped,
-    contextId: pgCore.varchar("context_id", { length: 256 }).notNull(),
-    status: pgCore.varchar("status", { length: 256 }).notNull(),
-    metadata: pgCore.jsonb("metadata").$type(),
-    ...timestamps
-  },
-  (table) => [
-    pgCore.primaryKey({ columns: [table.tenantId, table.projectId, table.id] }),
-    pgCore.foreignKey({
-      columns: [table.tenantId, table.projectId, table.agentId, table.subAgentId],
-      foreignColumns: [subAgents.tenantId, subAgents.projectId, subAgents.agentId, subAgents.id],
-      name: "tasks_sub_agent_fk"
-    }).onDelete("cascade")
-  ]
-);
-var taskRelations = pgCore.pgTable(
-  "task_relations",
-  {
-    ...projectScoped,
-    parentTaskId: pgCore.varchar("parent_task_id", { length: 256 }).notNull(),
-    childTaskId: pgCore.varchar("child_task_id", { length: 256 }).notNull(),
-    relationType: pgCore.varchar("relation_type", { length: 256 }).default("parent_child"),
-    ...timestamps
-  },
-  (table) => [
-    pgCore.primaryKey({ columns: [table.tenantId, table.projectId, table.id] }),
-    pgCore.foreignKey({
-      columns: [table.tenantId, table.projectId],
-      foreignColumns: [projects.tenantId, projects.id],
-      name: "task_relations_project_fk"
-    }).onDelete("cascade")
-  ]
-);
-var dataComponents = pgCore.pgTable(
-  "data_components",
-  {
-    ...projectScoped,
-    ...uiProperties,
-    props: pgCore.jsonb("props").$type(),
-    render: pgCore.jsonb("render").$type(),
-    ...timestamps
-  },
-  (table) => [
-    pgCore.primaryKey({ columns: [table.tenantId, table.projectId, table.id] }),
-    pgCore.foreignKey({
-      columns: [table.tenantId, table.projectId],
-      foreignColumns: [projects.tenantId, projects.id],
-      name: "data_components_project_fk"
-    }).onDelete("cascade")
-  ]
-);
-var subAgentDataComponents = pgCore.pgTable(
-  "sub_agent_data_components",
-  {
-    ...subAgentScoped,
-    dataComponentId: pgCore.varchar("data_component_id", { length: 256 }).notNull(),
-    createdAt: pgCore.timestamp("created_at", { mode: "string" }).notNull().defaultNow()
-  },
-  (table) => [
-    pgCore.primaryKey({ columns: [table.tenantId, table.projectId, table.id] }),
-    pgCore.foreignKey({
-      columns: [table.tenantId, table.projectId, table.agentId, table.subAgentId],
-      foreignColumns: [subAgents.tenantId, subAgents.projectId, subAgents.agentId, subAgents.id],
-      name: "sub_agent_data_components_sub_agent_fk"
-    }).onDelete("cascade"),
-    pgCore.foreignKey({
-      columns: [table.tenantId, table.projectId, table.dataComponentId],
-      foreignColumns: [dataComponents.tenantId, dataComponents.projectId, dataComponents.id],
-      name: "sub_agent_data_components_data_component_fk"
-    }).onDelete("cascade")
-  ]
-);
-var artifactComponents = pgCore.pgTable(
-  "artifact_components",
-  {
-    ...projectScoped,
-    ...uiProperties,
-    props: pgCore.jsonb("props").$type(),
-    ...timestamps
-  },
-  (table) => [
-    pgCore.primaryKey({ columns: [table.tenantId, table.projectId, table.id] }),
-    pgCore.foreignKey({
-      columns: [table.tenantId, table.projectId],
-      foreignColumns: [projects.tenantId, projects.id],
-      name: "artifact_components_project_fk"
-    }).onDelete("cascade")
-  ]
-);
-var subAgentArtifactComponents = pgCore.pgTable(
-  "sub_agent_artifact_components",
-  {
-    ...subAgentScoped,
-    artifactComponentId: pgCore.varchar("artifact_component_id", { length: 256 }).notNull(),
-    createdAt: pgCore.timestamp("created_at", { mode: "string" }).notNull().defaultNow()
-  },
-  (table) => [
-    pgCore.primaryKey({
-      columns: [table.tenantId, table.projectId, table.agentId, table.subAgentId, table.id]
-    }),
-    pgCore.foreignKey({
-      columns: [table.tenantId, table.projectId, table.agentId, table.subAgentId],
-      foreignColumns: [subAgents.tenantId, subAgents.projectId, subAgents.agentId, subAgents.id],
-      name: "sub_agent_artifact_components_sub_agent_fk"
-    }).onDelete("cascade"),
-    pgCore.foreignKey({
-      columns: [table.tenantId, table.projectId, table.artifactComponentId],
-      foreignColumns: [
-        artifactComponents.tenantId,
-        artifactComponents.projectId,
-        artifactComponents.id
-      ],
-      name: "sub_agent_artifact_components_artifact_component_fk"
-    }).onDelete("cascade")
-  ]
-);
-var tools = pgCore.pgTable(
-  "tools",
-  {
-    ...projectScoped,
-    name: pgCore.varchar("name", { length: 256 }).notNull(),
-    description: pgCore.text("description"),
-    config: pgCore.jsonb("config").$type().notNull(),
-    credentialReferenceId: pgCore.varchar("credential_reference_id", { length: 256 }),
-    headers: pgCore.jsonb("headers").$type(),
-    imageUrl: pgCore.text("image_url"),
-    capabilities: pgCore.jsonb("capabilities").$type(),
-    lastError: pgCore.text("last_error"),
-    ...timestamps
-  },
-  (table) => [
-    pgCore.primaryKey({ columns: [table.tenantId, table.projectId, table.id] }),
-    pgCore.foreignKey({
-      columns: [table.tenantId, table.projectId],
-      foreignColumns: [projects.tenantId, projects.id],
-      name: "tools_project_fk"
-    }).onDelete("cascade")
-  ]
-);
-var functionTools = pgCore.pgTable(
-  "function_tools",
-  {
-    ...agentScoped,
-    name: pgCore.varchar("name", { length: 256 }).notNull(),
-    description: pgCore.text("description"),
-    functionId: pgCore.varchar("function_id", { length: 256 }).notNull(),
-    ...timestamps
-  },
-  (table) => [
-    pgCore.primaryKey({ columns: [table.tenantId, table.projectId, table.agentId, table.id] }),
-    pgCore.foreignKey({
-      columns: [table.tenantId, table.projectId, table.agentId],
-      foreignColumns: [agents.tenantId, agents.projectId, agents.id],
-      name: "function_tools_agent_fk"
-    }).onDelete("cascade"),
-    pgCore.foreignKey({
-      columns: [table.tenantId, table.projectId, table.functionId],
-      foreignColumns: [functions.tenantId, functions.projectId, functions.id],
-      name: "function_tools_function_fk"
-    }).onDelete("cascade")
-  ]
-);
-var functions = pgCore.pgTable(
-  "functions",
-  {
-    ...projectScoped,
-    inputSchema: pgCore.jsonb("input_schema").$type(),
-    executeCode: pgCore.text("execute_code").notNull(),
-    dependencies: pgCore.jsonb("dependencies").$type(),
-    ...timestamps
-  },
-  (table) => [
-    pgCore.primaryKey({ columns: [table.tenantId, table.projectId, table.id] }),
-    pgCore.foreignKey({
-      columns: [table.tenantId, table.projectId],
-      foreignColumns: [projects.tenantId, projects.id],
-      name: "functions_project_fk"
-    }).onDelete("cascade")
-  ]
-);
-var subAgentToolRelations = pgCore.pgTable(
-  "sub_agent_tool_relations",
-  {
-    ...subAgentScoped,
-    toolId: pgCore.varchar("tool_id", { length: 256 }).notNull(),
-    selectedTools: pgCore.jsonb("selected_tools").$type(),
-    headers: pgCore.jsonb("headers").$type(),
-    ...timestamps
-  },
-  (table) => [
-    pgCore.primaryKey({ columns: [table.tenantId, table.projectId, table.agentId, table.id] }),
-    pgCore.foreignKey({
-      columns: [table.tenantId, table.projectId, table.agentId, table.subAgentId],
-      foreignColumns: [subAgents.tenantId, subAgents.projectId, subAgents.agentId, subAgents.id],
-      name: "sub_agent_tool_relations_agent_fk"
-    }).onDelete("cascade"),
-    pgCore.foreignKey({
-      columns: [table.tenantId, table.projectId, table.toolId],
-      foreignColumns: [tools.tenantId, tools.projectId, tools.id],
-      name: "sub_agent_tool_relations_tool_fk"
-    }).onDelete("cascade")
-  ]
-);
-var subAgentExternalAgentRelations = pgCore.pgTable(
-  "sub_agent_external_agent_relations",
-  {
-    ...subAgentScoped,
-    externalAgentId: pgCore.varchar("external_agent_id", { length: 256 }).notNull(),
-    headers: pgCore.jsonb("headers").$type(),
-    ...timestamps
-  },
-  (table) => [
-    pgCore.primaryKey({ columns: [table.tenantId, table.projectId, table.agentId, table.id] }),
-    pgCore.foreignKey({
-      columns: [table.tenantId, table.projectId, table.agentId, table.subAgentId],
-      foreignColumns: [subAgents.tenantId, subAgents.projectId, subAgents.agentId, subAgents.id],
-      name: "sub_agent_external_agent_relations_sub_agent_fk"
-    }).onDelete("cascade"),
-    pgCore.foreignKey({
-      columns: [table.tenantId, table.projectId, table.externalAgentId],
-      foreignColumns: [externalAgents.tenantId, externalAgents.projectId, externalAgents.id],
-      name: "sub_agent_external_agent_relations_external_agent_fk"
-    }).onDelete("cascade")
-  ]
-);
-var subAgentTeamAgentRelations = pgCore.pgTable(
-  "sub_agent_team_agent_relations",
-  {
-    ...subAgentScoped,
-    targetAgentId: pgCore.varchar("target_agent_id", { length: 256 }).notNull(),
-    headers: pgCore.jsonb("headers").$type(),
-    ...timestamps
-  },
-  (table) => [
-    pgCore.primaryKey({ columns: [table.tenantId, table.projectId, table.agentId, table.id] }),
-    pgCore.foreignKey({
-      columns: [table.tenantId, table.projectId, table.agentId, table.subAgentId],
-      foreignColumns: [subAgents.tenantId, subAgents.projectId, subAgents.agentId, subAgents.id],
-      name: "sub_agent_team_agent_relations_sub_agent_fk"
-    }).onDelete("cascade"),
-    pgCore.foreignKey({
-      columns: [table.tenantId, table.projectId, table.targetAgentId],
-      foreignColumns: [agents.tenantId, agents.projectId, agents.id],
-      name: "sub_agent_team_agent_relations_target_agent_fk"
-    }).onDelete("cascade")
-  ]
-);
-var subAgentFunctionToolRelations = pgCore.pgTable(
-  "sub_agent_function_tool_relations",
-  {
-    ...subAgentScoped,
-    functionToolId: pgCore.varchar("function_tool_id", { length: 256 }).notNull(),
-    ...timestamps
-  },
-  (table) => [
-    pgCore.primaryKey({ columns: [table.tenantId, table.projectId, table.agentId, table.id] }),
-    pgCore.foreignKey({
-      columns: [table.tenantId, table.projectId, table.agentId, table.subAgentId],
-      foreignColumns: [subAgents.tenantId, subAgents.projectId, subAgents.agentId, subAgents.id],
-      name: "sub_agent_function_tool_relations_sub_agent_fk"
-    }).onDelete("cascade"),
-    pgCore.foreignKey({
-      columns: [table.tenantId, table.projectId, table.agentId, table.functionToolId],
-      foreignColumns: [
-        functionTools.tenantId,
-        functionTools.projectId,
-        functionTools.agentId,
-        functionTools.id
-      ],
-      name: "sub_agent_function_tool_relations_function_tool_fk"
-    }).onDelete("cascade")
-  ]
-);
-var conversations = pgCore.pgTable(
-  "conversations",
-  {
-    ...projectScoped,
-    userId: pgCore.varchar("user_id", { length: 256 }),
-    activeSubAgentId: pgCore.varchar("active_sub_agent_id", { length: 256 }).notNull(),
-    title: pgCore.text("title"),
-    lastContextResolution: pgCore.timestamp("last_context_resolution", { mode: "string" }),
-    metadata: pgCore.jsonb("metadata").$type(),
-    ...timestamps
-  },
-  (table) => [
-    pgCore.primaryKey({ columns: [table.tenantId, table.projectId, table.id] }),
-    pgCore.foreignKey({
-      columns: [table.tenantId, table.projectId],
-      foreignColumns: [projects.tenantId, projects.id],
-      name: "conversations_project_fk"
-    }).onDelete("cascade")
-  ]
-);
-var messages = pgCore.pgTable(
-  "messages",
-  {
-    ...projectScoped,
-    conversationId: pgCore.varchar("conversation_id", { length: 256 }).notNull(),
-    role: pgCore.varchar("role", { length: 256 }).notNull(),
-    fromSubAgentId: pgCore.varchar("from_sub_agent_id", { length: 256 }),
-    toSubAgentId: pgCore.varchar("to_sub_agent_id", { length: 256 }),
-    fromExternalAgentId: pgCore.varchar("from_external_sub_agent_id", { length: 256 }),
-    toExternalAgentId: pgCore.varchar("to_external_sub_agent_id", { length: 256 }),
-    fromTeamAgentId: pgCore.varchar("from_team_agent_id", { length: 256 }),
-    toTeamAgentId: pgCore.varchar("to_team_agent_id", { length: 256 }),
-    content: pgCore.jsonb("content").$type().notNull(),
-    visibility: pgCore.varchar("visibility", { length: 256 }).notNull().default("user-facing"),
-    messageType: pgCore.varchar("message_type", { length: 256 }).notNull().default("chat"),
-    taskId: pgCore.varchar("task_id", { length: 256 }),
-    parentMessageId: pgCore.varchar("parent_message_id", { length: 256 }),
-    a2aTaskId: pgCore.varchar("a2a_task_id", { length: 256 }),
-    a2aSessionId: pgCore.varchar("a2a_session_id", { length: 256 }),
-    metadata: pgCore.jsonb("metadata").$type(),
-    ...timestamps
-  },
-  (table) => [
-    pgCore.primaryKey({ columns: [table.tenantId, table.projectId, table.id] }),
-    pgCore.foreignKey({
-      columns: [table.tenantId, table.projectId],
-      foreignColumns: [projects.tenantId, projects.id],
-      name: "messages_project_fk"
-    }).onDelete("cascade")
-  ]
-);
-var ledgerArtifacts = pgCore.pgTable(
-  "ledger_artifacts",
-  {
-    ...projectScoped,
-    taskId: pgCore.varchar("task_id", { length: 256 }).notNull(),
-    toolCallId: pgCore.varchar("tool_call_id", { length: 256 }),
-    contextId: pgCore.varchar("context_id", { length: 256 }).notNull(),
-    type: pgCore.varchar("type", { length: 256 }).notNull().default("source"),
-    name: pgCore.varchar("name", { length: 256 }),
-    description: pgCore.text("description"),
-    parts: pgCore.jsonb("parts").$type(),
-    metadata: pgCore.jsonb("metadata").$type(),
-    summary: pgCore.text("summary"),
-    mime: pgCore.jsonb("mime").$type(),
-    visibility: pgCore.varchar("visibility", { length: 256 }).default("context"),
-    allowedAgents: pgCore.jsonb("allowed_agents").$type(),
-    derivedFrom: pgCore.varchar("derived_from", { length: 256 }),
-    ...timestamps
-  },
-  (table) => [
-    pgCore.primaryKey({ columns: [table.tenantId, table.projectId, table.id, table.taskId] }),
-    pgCore.foreignKey({
-      columns: [table.tenantId, table.projectId],
-      foreignColumns: [projects.tenantId, projects.id],
-      name: "ledger_artifacts_project_fk"
-    }).onDelete("cascade"),
-    pgCore.index("ledger_artifacts_task_id_idx").on(table.taskId),
-    pgCore.index("ledger_artifacts_tool_call_id_idx").on(table.toolCallId),
-    pgCore.index("ledger_artifacts_context_id_idx").on(table.contextId),
-    pgCore.unique("ledger_artifacts_task_context_name_unique").on(
-      table.taskId,
-      table.contextId,
-      table.name
-    )
-  ]
-);
-var apiKeys = pgCore.pgTable(
-  "api_keys",
-  {
-    ...agentScoped,
-    publicId: pgCore.varchar("public_id", { length: 256 }).notNull().unique(),
-    keyHash: pgCore.varchar("key_hash", { length: 256 }).notNull(),
-    keyPrefix: pgCore.varchar("key_prefix", { length: 256 }).notNull(),
-    name: pgCore.varchar("name", { length: 256 }),
-    lastUsedAt: pgCore.timestamp("last_used_at", { mode: "string" }),
-    expiresAt: pgCore.timestamp("expires_at", { mode: "string" }),
-    ...timestamps
-  },
-  (t) => [
-    pgCore.foreignKey({
-      columns: [t.tenantId],
-      foreignColumns: [organization.id],
-      name: "api_keys_organization_fk"
-    }).onDelete("cascade"),
-    pgCore.foreignKey({
-      columns: [t.tenantId, t.projectId],
-      foreignColumns: [projects.tenantId, projects.id],
-      name: "api_keys_project_fk"
-    }).onDelete("cascade"),
-    pgCore.foreignKey({
-      columns: [t.tenantId, t.projectId, t.agentId],
-      foreignColumns: [agents.tenantId, agents.projectId, agents.id],
-      name: "api_keys_agent_fk"
-    }).onDelete("cascade"),
-    pgCore.index("api_keys_tenant_agent_idx").on(t.tenantId, t.agentId),
-    pgCore.index("api_keys_prefix_idx").on(t.keyPrefix),
-    pgCore.index("api_keys_public_id_idx").on(t.publicId)
-  ]
-);
-var credentialReferences = pgCore.pgTable(
-  "credential_references",
-  {
-    ...projectScoped,
-    name: pgCore.varchar("name", { length: 256 }).notNull(),
-    type: pgCore.varchar("type", { length: 256 }).notNull(),
-    credentialStoreId: pgCore.varchar("credential_store_id", { length: 256 }).notNull(),
-    retrievalParams: pgCore.jsonb("retrieval_params").$type(),
-    ...timestamps
-  },
-  (t) => [
-    pgCore.primaryKey({ columns: [t.tenantId, t.projectId, t.id] }),
-    pgCore.foreignKey({
-      columns: [t.tenantId, t.projectId],
-      foreignColumns: [projects.tenantId, projects.id],
-      name: "credential_references_project_fk"
-    }).onDelete("cascade")
-  ]
-);
-drizzleOrm.relations(tasks, ({ one, many }) => ({
-  project: one(projects, {
-    fields: [tasks.tenantId, tasks.projectId],
-    references: [projects.tenantId, projects.id]
-  }),
-  // A task can have many parent relationships (where it's the child)
-  parentRelations: many(taskRelations, {
-    relationName: "childTask"
-  }),
-  // A task can have many child relationships (where it's the parent)
-  childRelations: many(taskRelations, {
-    relationName: "parentTask"
-  }),
-  subAgent: one(subAgents, {
-    fields: [tasks.subAgentId],
-    references: [subAgents.id]
-  }),
-  messages: many(messages),
-  ledgerArtifacts: many(ledgerArtifacts)
-}));
-drizzleOrm.relations(projects, ({ many }) => ({
-  subAgents: many(subAgents),
-  agents: many(agents),
-  tools: many(tools),
-  functions: many(functions),
-  contextConfigs: many(contextConfigs),
-  externalAgents: many(externalAgents),
-  conversations: many(conversations),
-  tasks: many(tasks),
-  dataComponents: many(dataComponents),
-  artifactComponents: many(artifactComponents),
-  ledgerArtifacts: many(ledgerArtifacts),
-  credentialReferences: many(credentialReferences)
-}));
-drizzleOrm.relations(taskRelations, ({ one }) => ({
-  parentTask: one(tasks, {
-    fields: [taskRelations.parentTaskId],
-    references: [tasks.id],
-    relationName: "parentTask"
-  }),
-  childTask: one(tasks, {
-    fields: [taskRelations.childTaskId],
-    references: [tasks.id],
-    relationName: "childTask"
-  })
-}));
-drizzleOrm.relations(contextConfigs, ({ many, one }) => ({
-  project: one(projects, {
-    fields: [contextConfigs.tenantId, contextConfigs.projectId],
-    references: [projects.tenantId, projects.id]
-  }),
-  agents: many(agents),
-  cache: many(contextCache)
-}));
-drizzleOrm.relations(contextCache, ({ one }) => ({
-  contextConfig: one(contextConfigs, {
-    fields: [contextCache.contextConfigId],
-    references: [contextConfigs.id]
-  })
-}));
-drizzleOrm.relations(subAgents, ({ many, one }) => ({
-  project: one(projects, {
-    fields: [subAgents.tenantId, subAgents.projectId],
-    references: [projects.tenantId, projects.id]
-  }),
-  tasks: many(tasks),
-  defaultForAgents: many(agents),
-  sourceRelations: many(subAgentRelations, {
-    relationName: "sourceRelations"
-  }),
-  targetRelations: many(subAgentRelations, {
-    relationName: "targetRelations"
-  }),
-  sentMessages: many(messages, {
-    relationName: "sentMessages"
-  }),
-  receivedMessages: many(messages, {
-    relationName: "receivedMessages"
-  }),
-  toolRelations: many(subAgentToolRelations),
-  functionToolRelations: many(subAgentFunctionToolRelations),
-  dataComponentRelations: many(subAgentDataComponents),
-  artifactComponentRelations: many(subAgentArtifactComponents)
-}));
-drizzleOrm.relations(agents, ({ one, many }) => ({
-  project: one(projects, {
-    fields: [agents.tenantId, agents.projectId],
-    references: [projects.tenantId, projects.id]
-  }),
-  defaultSubAgent: one(subAgents, {
-    fields: [agents.defaultSubAgentId],
-    references: [subAgents.id]
-  }),
-  contextConfig: one(contextConfigs, {
-    fields: [agents.contextConfigId],
-    references: [contextConfigs.id]
-  }),
-  functionTools: many(functionTools)
-}));
-drizzleOrm.relations(externalAgents, ({ one, many }) => ({
-  project: one(projects, {
-    fields: [externalAgents.tenantId, externalAgents.projectId],
-    references: [projects.tenantId, projects.id]
-  }),
-  subAgentExternalAgentRelations: many(subAgentExternalAgentRelations),
-  credentialReference: one(credentialReferences, {
-    fields: [externalAgents.credentialReferenceId],
-    references: [credentialReferences.id]
-  })
-}));
-drizzleOrm.relations(apiKeys, ({ one }) => ({
-  project: one(projects, {
-    fields: [apiKeys.tenantId, apiKeys.projectId],
-    references: [projects.tenantId, projects.id]
-  }),
-  agent: one(agents, {
-    fields: [apiKeys.agentId],
-    references: [agents.id]
-  })
-}));
-drizzleOrm.relations(subAgentToolRelations, ({ one }) => ({
-  subAgent: one(subAgents, {
-    fields: [subAgentToolRelations.subAgentId],
-    references: [subAgents.id]
-  }),
-  tool: one(tools, {
-    fields: [subAgentToolRelations.toolId],
-    references: [tools.id]
-  })
-}));
-drizzleOrm.relations(credentialReferences, ({ one, many }) => ({
-  project: one(projects, {
-    fields: [credentialReferences.tenantId, credentialReferences.projectId],
-    references: [projects.tenantId, projects.id]
-  }),
-  tools: many(tools),
-  externalAgents: many(externalAgents)
-}));
-drizzleOrm.relations(tools, ({ one, many }) => ({
-  project: one(projects, {
-    fields: [tools.tenantId, tools.projectId],
-    references: [projects.tenantId, projects.id]
-  }),
-  subAgentRelations: many(subAgentToolRelations),
-  credentialReference: one(credentialReferences, {
-    fields: [tools.credentialReferenceId],
-    references: [credentialReferences.id]
-  })
-}));
-drizzleOrm.relations(conversations, ({ one, many }) => ({
-  project: one(projects, {
-    fields: [conversations.tenantId, conversations.projectId],
-    references: [projects.tenantId, projects.id]
-  }),
-  messages: many(messages),
-  activeSubAgent: one(subAgents, {
-    fields: [conversations.activeSubAgentId],
-    references: [subAgents.id]
-  })
-}));
-drizzleOrm.relations(messages, ({ one, many }) => ({
-  conversation: one(conversations, {
-    fields: [messages.conversationId],
-    references: [conversations.id]
-  }),
-  fromSubAgent: one(subAgents, {
-    fields: [messages.fromSubAgentId],
-    references: [subAgents.id],
-    relationName: "sentMessages"
-  }),
-  toSubAgent: one(subAgents, {
-    fields: [messages.toSubAgentId],
-    references: [subAgents.id],
-    relationName: "receivedMessages"
-  }),
-  fromTeamAgent: one(agents, {
-    fields: [messages.fromTeamAgentId],
-    references: [agents.id],
-    relationName: "receivedTeamMessages"
-  }),
-  toTeamAgent: one(agents, {
-    fields: [messages.toTeamAgentId],
-    references: [agents.id],
-    relationName: "sentTeamMessages"
-  }),
-  fromExternalAgent: one(externalAgents, {
-    fields: [messages.tenantId, messages.projectId, messages.fromExternalAgentId],
-    references: [externalAgents.tenantId, externalAgents.projectId, externalAgents.id],
-    relationName: "receivedExternalMessages"
-  }),
-  toExternalAgent: one(externalAgents, {
-    fields: [messages.tenantId, messages.projectId, messages.toExternalAgentId],
-    references: [externalAgents.tenantId, externalAgents.projectId, externalAgents.id],
-    relationName: "sentExternalMessages"
-  }),
-  task: one(tasks, {
-    fields: [messages.taskId],
-    references: [tasks.id]
-  }),
-  parentMessage: one(messages, {
-    fields: [messages.parentMessageId],
-    references: [messages.id],
-    relationName: "parentChild"
-  }),
-  childMessages: many(messages, {
-    relationName: "parentChild"
-  })
-}));
-drizzleOrm.relations(artifactComponents, ({ many, one }) => ({
-  project: one(projects, {
-    fields: [artifactComponents.tenantId, artifactComponents.projectId],
-    references: [projects.tenantId, projects.id]
-  }),
-  subAgentRelations: many(subAgentArtifactComponents)
-}));
-drizzleOrm.relations(
-  subAgentArtifactComponents,
-  ({ one }) => ({
-    subAgent: one(subAgents, {
-      fields: [subAgentArtifactComponents.subAgentId],
-      references: [subAgents.id]
-    }),
-    artifactComponent: one(artifactComponents, {
-      fields: [subAgentArtifactComponents.artifactComponentId],
-      references: [artifactComponents.id]
-    })
-  })
-);
-drizzleOrm.relations(dataComponents, ({ many, one }) => ({
-  project: one(projects, {
-    fields: [dataComponents.tenantId, dataComponents.projectId],
-    references: [projects.tenantId, projects.id]
-  }),
-  subAgentRelations: many(subAgentDataComponents)
-}));
-drizzleOrm.relations(subAgentDataComponents, ({ one }) => ({
-  subAgent: one(subAgents, {
-    fields: [subAgentDataComponents.subAgentId],
-    references: [subAgents.id]
-  }),
-  dataComponent: one(dataComponents, {
-    fields: [subAgentDataComponents.dataComponentId],
-    references: [dataComponents.id]
-  })
-}));
-drizzleOrm.relations(ledgerArtifacts, ({ one }) => ({
-  project: one(projects, {
-    fields: [ledgerArtifacts.tenantId, ledgerArtifacts.projectId],
-    references: [projects.tenantId, projects.id]
-  }),
-  task: one(tasks, {
-    fields: [ledgerArtifacts.taskId],
-    references: [tasks.id]
-  })
-}));
-drizzleOrm.relations(functions, ({ many, one }) => ({
-  functionTools: many(functionTools),
-  project: one(projects, {
-    fields: [functions.tenantId, functions.projectId],
-    references: [projects.tenantId, projects.id]
-  })
-}));
-drizzleOrm.relations(subAgentRelations, ({ one }) => ({
-  agent: one(agents, {
-    fields: [subAgentRelations.agentId],
-    references: [agents.id]
-  }),
-  sourceSubAgent: one(subAgents, {
-    fields: [subAgentRelations.sourceSubAgentId],
-    references: [subAgents.id],
-    relationName: "sourceRelations"
-  }),
-  targetSubAgent: one(subAgents, {
-    fields: [subAgentRelations.targetSubAgentId],
-    references: [subAgents.id],
-    relationName: "targetRelations"
-  })
-}));
-drizzleOrm.relations(functionTools, ({ one, many }) => ({
-  project: one(projects, {
-    fields: [functionTools.tenantId, functionTools.projectId],
-    references: [projects.tenantId, projects.id]
-  }),
-  agent: one(agents, {
-    fields: [functionTools.tenantId, functionTools.projectId, functionTools.agentId],
-    references: [agents.tenantId, agents.projectId, agents.id]
-  }),
-  function: one(functions, {
-    fields: [functionTools.tenantId, functionTools.projectId, functionTools.functionId],
-    references: [functions.tenantId, functions.projectId, functions.id]
-  }),
-  subAgentRelations: many(subAgentFunctionToolRelations)
-}));
-drizzleOrm.relations(
-  subAgentFunctionToolRelations,
-  ({ one }) => ({
-    subAgent: one(subAgents, {
-      fields: [subAgentFunctionToolRelations.subAgentId],
-      references: [subAgents.id]
-    }),
-    functionTool: one(functionTools, {
-      fields: [subAgentFunctionToolRelations.functionToolId],
-      references: [functionTools.id]
-    })
-  })
-);
-drizzleOrm.relations(
-  subAgentExternalAgentRelations,
-  ({ one }) => ({
-    subAgent: one(subAgents, {
-      fields: [
-        subAgentExternalAgentRelations.tenantId,
-        subAgentExternalAgentRelations.projectId,
-        subAgentExternalAgentRelations.agentId,
-        subAgentExternalAgentRelations.subAgentId
-      ],
-      references: [subAgents.tenantId, subAgents.projectId, subAgents.agentId, subAgents.id]
-    }),
-    externalAgent: one(externalAgents, {
-      fields: [
-        subAgentExternalAgentRelations.tenantId,
-        subAgentExternalAgentRelations.projectId,
-        subAgentExternalAgentRelations.externalAgentId
-      ],
-      references: [externalAgents.tenantId, externalAgents.projectId, externalAgents.id]
-    })
-  })
-);
-drizzleOrm.relations(
-  subAgentTeamAgentRelations,
-  ({ one }) => ({
-    subAgent: one(subAgents, {
-      fields: [
-        subAgentTeamAgentRelations.tenantId,
-        subAgentTeamAgentRelations.projectId,
-        subAgentTeamAgentRelations.agentId,
-        subAgentTeamAgentRelations.subAgentId
-      ],
-      references: [subAgents.tenantId, subAgents.projectId, subAgents.agentId, subAgents.id]
-    }),
-    targetAgent: one(agents, {
-      fields: [
-        subAgentTeamAgentRelations.tenantId,
-        subAgentTeamAgentRelations.projectId,
-        subAgentTeamAgentRelations.targetAgentId
-      ],
-      references: [agents.tenantId, agents.projectId, agents.id]
-    })
-  })
-);
-var MIN_ID_LENGTH = 1;
-var MAX_ID_LENGTH = 255;
-var URL_SAFE_ID_PATTERN = /^[a-zA-Z0-9\-_.]+$/;
-var resourceIdSchema = zodOpenapi.z.string().min(MIN_ID_LENGTH).max(MAX_ID_LENGTH).describe("Resource identifier").regex(URL_SAFE_ID_PATTERN, {
-  message: "ID must contain only letters, numbers, hyphens, underscores, and dots"
-}).openapi({
-  description: "Resource identifier",
-  example: "resource_789"
-});
-resourceIdSchema.meta({
-  description: "Resource identifier"
-});
-var FIELD_MODIFIERS = {
-  id: (schema) => {
-    const modified = schema.min(MIN_ID_LENGTH).max(MAX_ID_LENGTH).describe("Resource identifier").regex(URL_SAFE_ID_PATTERN, {
-      message: "ID must contain only letters, numbers, hyphens, underscores, and dots"
-    }).openapi({
-      description: "Resource identifier",
-      example: "resource_789"
-    });
-    modified.meta({
-      description: "Resource identifier"
-    });
-    return modified;
-  },
-  name: (_schema) => {
-    const modified = zodOpenapi.z.string().describe("Name");
-    modified.meta({ description: "Name" });
-    return modified;
-  },
-  description: (_schema) => {
-    const modified = zodOpenapi.z.string().describe("Description");
-    modified.meta({ description: "Description" });
-    return modified;
-  },
-  tenantId: (schema) => {
-    const modified = schema.describe("Tenant identifier");
-    modified.meta({ description: "Tenant identifier" });
-    return modified;
-  },
-  projectId: (schema) => {
-    const modified = schema.describe("Project identifier");
-    modified.meta({ description: "Project identifier" });
-    return modified;
-  },
-  agentId: (schema) => {
-    const modified = schema.describe("Agent identifier");
-    modified.meta({ description: "Agent identifier" });
-    return modified;
-  },
-  subAgentId: (schema) => {
-    const modified = schema.describe("Sub-agent identifier");
-    modified.meta({ description: "Sub-agent identifier" });
-    return modified;
-  },
-  createdAt: (schema) => {
-    const modified = schema.describe("Creation timestamp");
-    modified.meta({ description: "Creation timestamp" });
-    return modified;
-  },
-  updatedAt: (schema) => {
-    const modified = schema.describe("Last update timestamp");
-    modified.meta({ description: "Last update timestamp" });
-    return modified;
-  }
-};
-function createSelectSchemaWithModifiers(table, overrides) {
-  const tableColumns = table._?.columns;
-  if (!tableColumns) {
-    return drizzleZod.createSelectSchema(table, overrides);
-  }
-  const tableFieldNames = Object.keys(tableColumns);
-  const modifiers = {};
-  for (const fieldName of tableFieldNames) {
-    const fieldNameStr = String(fieldName);
-    if (fieldNameStr in FIELD_MODIFIERS) {
-      modifiers[fieldNameStr] = FIELD_MODIFIERS[fieldNameStr];
-    }
-  }
-  const mergedModifiers = { ...modifiers, ...overrides };
-  return drizzleZod.createSelectSchema(table, mergedModifiers);
-}
-function createInsertSchemaWithModifiers(table, overrides) {
-  const tableColumns = table._?.columns;
-  if (!tableColumns) {
-    return drizzleZod.createInsertSchema(table, overrides);
-  }
-  const tableFieldNames = Object.keys(tableColumns);
-  const modifiers = {};
-  for (const fieldName of tableFieldNames) {
-    const fieldNameStr = String(fieldName);
-    if (fieldNameStr in FIELD_MODIFIERS) {
-      modifiers[fieldNameStr] = FIELD_MODIFIERS[fieldNameStr];
-    }
-  }
-  const mergedModifiers = { ...modifiers, ...overrides };
-  return drizzleZod.createInsertSchema(table, mergedModifiers);
-}
-var createSelectSchema = createSelectSchemaWithModifiers;
-var createInsertSchema = createInsertSchemaWithModifiers;
-function registerFieldSchemas(schema) {
-  if (!(schema instanceof zodOpenapi.z.ZodObject)) {
-    return schema;
-  }
-  const shape = schema.shape;
-  const fieldMetadata = {
-    id: { description: "Resource identifier" },
-    name: { description: "Name" },
-    description: { description: "Description" },
-    tenantId: { description: "Tenant identifier" },
-    projectId: { description: "Project identifier" },
-    agentId: { description: "Agent identifier" },
-    subAgentId: { description: "Sub-agent identifier" },
-    createdAt: { description: "Creation timestamp" },
-    updatedAt: { description: "Last update timestamp" }
-  };
-  for (const [fieldName, fieldSchema] of Object.entries(shape)) {
-    if (fieldName in fieldMetadata && fieldSchema) {
-      let zodFieldSchema = fieldSchema;
-      let innerSchema = null;
-      if (zodFieldSchema instanceof zodOpenapi.z.ZodOptional) {
-        innerSchema = zodFieldSchema._def.innerType;
-        zodFieldSchema = innerSchema;
-      }
-      zodFieldSchema.meta(fieldMetadata[fieldName]);
-      if (fieldName === "id" && zodFieldSchema instanceof zodOpenapi.z.ZodString) {
-        zodFieldSchema.openapi({
-          description: "Resource identifier",
-          minLength: MIN_ID_LENGTH,
-          maxLength: MAX_ID_LENGTH,
-          pattern: URL_SAFE_ID_PATTERN.source,
-          example: "resource_789"
-        });
-      } else if (zodFieldSchema instanceof zodOpenapi.z.ZodString) {
-        zodFieldSchema.openapi({
-          description: fieldMetadata[fieldName].description
-        });
-      }
-      if (innerSchema && fieldSchema instanceof zodOpenapi.z.ZodOptional) {
-        fieldSchema.meta(fieldMetadata[fieldName]);
-      }
-    }
-  }
-  return schema;
-}
-
-// src/validation/schemas.ts
-var {
-  AGENT_EXECUTION_TRANSFER_COUNT_MAX,
-  AGENT_EXECUTION_TRANSFER_COUNT_MIN,
-  CONTEXT_FETCHER_HTTP_TIMEOUT_MS_DEFAULT,
-  STATUS_UPDATE_MAX_INTERVAL_SECONDS,
-  STATUS_UPDATE_MAX_NUM_EVENTS,
-  SUB_AGENT_TURN_GENERATION_STEPS_MAX,
-  SUB_AGENT_TURN_GENERATION_STEPS_MIN,
-  VALIDATION_AGENT_PROMPT_MAX_CHARS,
-  VALIDATION_SUB_AGENT_PROMPT_MAX_CHARS
-} = schemaValidationDefaults;
-var StopWhenSchema = zodOpenapi.z.object({
-  transferCountIs: zodOpenapi.z.number().min(AGENT_EXECUTION_TRANSFER_COUNT_MIN).max(AGENT_EXECUTION_TRANSFER_COUNT_MAX).optional().describe("The maximum number of transfers to trigger the stop condition."),
-  stepCountIs: zodOpenapi.z.number().min(SUB_AGENT_TURN_GENERATION_STEPS_MIN).max(SUB_AGENT_TURN_GENERATION_STEPS_MAX).optional().describe("The maximum number of steps to trigger the stop condition.")
-}).openapi("StopWhen");
-var AgentStopWhenSchema = StopWhenSchema.pick({ transferCountIs: true }).openapi(
-  "AgentStopWhen"
-);
-var SubAgentStopWhenSchema = StopWhenSchema.pick({ stepCountIs: true }).openapi(
-  "SubAgentStopWhen"
-);
-var pageNumber = zodOpenapi.z.coerce.number().min(1).default(1).openapi("PaginationPageQueryParam");
-var limitNumber = zodOpenapi.z.coerce.number().min(1).max(100).default(10).openapi("PaginationLimitQueryParam");
-var ModelSettingsSchema = zodOpenapi.z.object({
-  model: zodOpenapi.z.string().optional().describe("The model to use for the project."),
-  providerOptions: zodOpenapi.z.record(zodOpenapi.z.string(), zodOpenapi.z.any()).optional().describe("The provider options to use for the project.")
-}).openapi("ModelSettings");
-var ModelSchema = zodOpenapi.z.object({
-  base: ModelSettingsSchema.optional(),
-  structuredOutput: ModelSettingsSchema.optional(),
-  summarizer: ModelSettingsSchema.optional()
-}).openapi("Model");
-var ProjectModelSchema = zodOpenapi.z.object({
-  base: ModelSettingsSchema,
-  structuredOutput: ModelSettingsSchema.optional(),
-  summarizer: ModelSettingsSchema.optional()
-}).openapi("ProjectModel");
-zodOpenapi.z.object({
-  name: zodOpenapi.z.string(),
-  description: zodOpenapi.z.string(),
-  inputSchema: zodOpenapi.z.record(zodOpenapi.z.string(), zodOpenapi.z.unknown()),
-  dependencies: zodOpenapi.z.record(zodOpenapi.z.string(), zodOpenapi.z.string()).optional(),
-  execute: zodOpenapi.z.union([zodOpenapi.z.function(), zodOpenapi.z.string()])
-});
-var createApiSchema = (schema) => schema.omit({ tenantId: true, projectId: true });
-var createApiInsertSchema = (schema) => schema.omit({ tenantId: true, projectId: true });
-var createApiUpdateSchema = (schema) => schema.omit({ tenantId: true, projectId: true }).partial();
-var createAgentScopedApiSchema = (schema) => schema.omit({ tenantId: true, projectId: true, agentId: true });
-var createAgentScopedApiInsertSchema = (schema) => schema.omit({ tenantId: true, projectId: true, agentId: true });
-var createAgentScopedApiUpdateSchema = (schema) => schema.omit({ tenantId: true, projectId: true, agentId: true }).partial();
-var SubAgentSelectSchema = createSelectSchema(subAgents);
-var SubAgentInsertSchema = createInsertSchema(subAgents).extend({
-  id: resourceIdSchema,
-  models: ModelSchema.optional()
-});
-var SubAgentUpdateSchema = SubAgentInsertSchema.partial();
-var SubAgentApiSelectSchema = createAgentScopedApiSchema(SubAgentSelectSchema).openapi("SubAgent");
-var SubAgentApiInsertSchema = createAgentScopedApiInsertSchema(SubAgentInsertSchema).openapi("SubAgentCreate");
-createAgentScopedApiUpdateSchema(SubAgentUpdateSchema).openapi("SubAgentUpdate");
-var SubAgentRelationSelectSchema = createSelectSchema(subAgentRelations);
-var SubAgentRelationInsertSchema = createInsertSchema(subAgentRelations).extend({
-  id: resourceIdSchema,
-  agentId: resourceIdSchema,
-  sourceSubAgentId: resourceIdSchema,
-  targetSubAgentId: resourceIdSchema.optional(),
-  externalSubAgentId: resourceIdSchema.optional(),
-  teamSubAgentId: resourceIdSchema.optional()
-});
-var SubAgentRelationUpdateSchema = SubAgentRelationInsertSchema.partial();
-var SubAgentRelationApiSelectSchema = createAgentScopedApiSchema(
-  SubAgentRelationSelectSchema
-).openapi("SubAgentRelation");
-createAgentScopedApiInsertSchema(
-  SubAgentRelationInsertSchema
-).extend({
-  relationType: zodOpenapi.z.enum(VALID_RELATION_TYPES)
-}).refine(
-  (data) => {
-    const hasTarget = data.targetSubAgentId != null;
-    const hasExternal = data.externalSubAgentId != null;
-    const hasTeam = data.teamSubAgentId != null;
-    const count = [hasTarget, hasExternal, hasTeam].filter(Boolean).length;
-    return count === 1;
-  },
-  {
-    message: "Must specify exactly one of targetSubAgentId, externalSubAgentId, or teamSubAgentId",
-    path: ["targetSubAgentId", "externalSubAgentId", "teamSubAgentId"]
-  }
-).openapi("SubAgentRelationCreate");
-createAgentScopedApiUpdateSchema(
-  SubAgentRelationUpdateSchema
-).extend({
-  relationType: zodOpenapi.z.enum(VALID_RELATION_TYPES).optional()
-}).refine(
-  (data) => {
-    const hasTarget = data.targetSubAgentId != null;
-    const hasExternal = data.externalSubAgentId != null;
-    const hasTeam = data.teamSubAgentId != null;
-    const count = [hasTarget, hasExternal, hasTeam].filter(Boolean).length;
-    if (count === 0) {
-      return true;
-    }
-    return count === 1;
-  },
-  {
-    message: "Must specify exactly one of targetSubAgentId, externalSubAgentId, or teamSubAgentId when updating sub-agent relationships",
-    path: ["targetSubAgentId", "externalSubAgentId", "teamSubAgentId"]
-  }
-).openapi("SubAgentRelationUpdate");
-zodOpenapi.z.object({
-  sourceSubAgentId: zodOpenapi.z.string().optional(),
-  targetSubAgentId: zodOpenapi.z.string().optional(),
-  externalSubAgentId: zodOpenapi.z.string().optional(),
-  teamSubAgentId: zodOpenapi.z.string().optional()
-});
-var ExternalSubAgentRelationInsertSchema = createInsertSchema(subAgentRelations).extend({
-  id: resourceIdSchema,
-  agentId: resourceIdSchema,
-  sourceSubAgentId: resourceIdSchema,
-  externalSubAgentId: resourceIdSchema
-});
-createApiInsertSchema(
-  ExternalSubAgentRelationInsertSchema
-);
-var AgentSelectSchema = createSelectSchema(agents);
-var AgentInsertSchema = createInsertSchema(agents).extend({
-  id: resourceIdSchema,
-  name: zodOpenapi.z.string().trim().nonempty()
-});
-var AgentUpdateSchema = AgentInsertSchema.partial();
-var AgentApiSelectSchema = createApiSchema(AgentSelectSchema).openapi("Agent");
-var AgentApiInsertSchema = createApiInsertSchema(AgentInsertSchema).extend({
-  id: resourceIdSchema
-}).openapi("AgentCreate");
-createApiUpdateSchema(AgentUpdateSchema).openapi("AgentUpdate");
-var TaskSelectSchema = createSelectSchema(tasks);
-var TaskInsertSchema = createInsertSchema(tasks).extend({
-  id: resourceIdSchema,
-  conversationId: resourceIdSchema.optional()
-});
-var TaskUpdateSchema = TaskInsertSchema.partial();
-createApiSchema(TaskSelectSchema);
-createApiInsertSchema(TaskInsertSchema);
-createApiUpdateSchema(TaskUpdateSchema);
-var TaskRelationSelectSchema = createSelectSchema(taskRelations);
-var TaskRelationInsertSchema = createInsertSchema(taskRelations).extend({
-  id: resourceIdSchema,
-  parentTaskId: resourceIdSchema,
-  childTaskId: resourceIdSchema
-});
-var TaskRelationUpdateSchema = TaskRelationInsertSchema.partial();
-createApiSchema(TaskRelationSelectSchema);
-createApiInsertSchema(TaskRelationInsertSchema);
-createApiUpdateSchema(TaskRelationUpdateSchema);
-var imageUrlSchema = zodOpenapi.z.string().optional().refine(
-  (url) => {
-    if (!url) return true;
-    if (url.startsWith("data:image/")) {
-      const base64Part = url.split(",")[1];
-      if (!base64Part) return false;
-      return base64Part.length < 14e5;
-    }
-    try {
-      const parsed = new URL(url);
-      return parsed.protocol === "http:" || parsed.protocol === "https:";
-    } catch {
-      return false;
-    }
-  },
-  {
-    message: "Image URL must be a valid HTTP(S) URL or a base64 data URL (max 1MB)"
-  }
-);
-var McpTransportConfigSchema = zodOpenapi.z.object({
-  type: zodOpenapi.z.enum(MCPTransportType),
-  requestInit: zodOpenapi.z.record(zodOpenapi.z.string(), zodOpenapi.z.unknown()).optional(),
-  eventSourceInit: zodOpenapi.z.record(zodOpenapi.z.string(), zodOpenapi.z.unknown()).optional(),
-  reconnectionOptions: zodOpenapi.z.any().optional().openapi({
-    type: "object",
-    description: "Reconnection options for streamable HTTP transport"
-  }),
-  sessionId: zodOpenapi.z.string().optional()
-}).openapi("McpTransportConfig");
-var ToolStatusSchema = zodOpenapi.z.enum(TOOL_STATUS_VALUES);
-var McpToolDefinitionSchema = zodOpenapi.z.object({
-  name: zodOpenapi.z.string(),
-  description: zodOpenapi.z.string().optional(),
-  inputSchema: zodOpenapi.z.record(zodOpenapi.z.string(), zodOpenapi.z.unknown()).optional()
-});
-var ToolSelectSchema = createSelectSchema(tools);
-var ToolInsertSchema = createInsertSchema(tools).extend({
-  id: resourceIdSchema,
-  imageUrl: imageUrlSchema,
-  config: zodOpenapi.z.object({
-    type: zodOpenapi.z.literal("mcp"),
-    mcp: zodOpenapi.z.object({
-      server: zodOpenapi.z.object({
-        url: zodOpenapi.z.url()
-      }),
-      transport: zodOpenapi.z.object({
-        type: zodOpenapi.z.enum(MCPTransportType),
-        requestInit: zodOpenapi.z.record(zodOpenapi.z.string(), zodOpenapi.z.unknown()).optional(),
-        eventSourceInit: zodOpenapi.z.record(zodOpenapi.z.string(), zodOpenapi.z.unknown()).optional(),
-        reconnectionOptions: zodOpenapi.z.any().optional().openapi({
-          type: "object",
-          description: "Reconnection options for streamable HTTP transport"
-        }),
-        sessionId: zodOpenapi.z.string().optional()
-      }).optional(),
-      activeTools: zodOpenapi.z.array(zodOpenapi.z.string()).optional()
-    })
-  })
-});
-var ConversationSelectSchema = createSelectSchema(conversations);
-var ConversationInsertSchema = createInsertSchema(conversations).extend({
-  id: resourceIdSchema,
-  contextConfigId: resourceIdSchema.optional()
-});
-var ConversationUpdateSchema = ConversationInsertSchema.partial();
-var ConversationApiSelectSchema = createApiSchema(ConversationSelectSchema).openapi("Conversation");
-createApiInsertSchema(ConversationInsertSchema).openapi("ConversationCreate");
-createApiUpdateSchema(ConversationUpdateSchema).openapi("ConversationUpdate");
-var MessageSelectSchema = createSelectSchema(messages);
-var MessageInsertSchema = createInsertSchema(messages).extend({
-  id: resourceIdSchema,
-  conversationId: resourceIdSchema,
-  taskId: resourceIdSchema.optional()
-});
-var MessageUpdateSchema = MessageInsertSchema.partial();
-var MessageApiSelectSchema = createApiSchema(MessageSelectSchema).openapi("Message");
-createApiInsertSchema(MessageInsertSchema).openapi("MessageCreate");
-createApiUpdateSchema(MessageUpdateSchema).openapi("MessageUpdate");
-var ContextCacheSelectSchema = createSelectSchema(contextCache);
-var ContextCacheInsertSchema = createInsertSchema(contextCache);
-var ContextCacheUpdateSchema = ContextCacheInsertSchema.partial();
-createApiSchema(ContextCacheSelectSchema);
-createApiInsertSchema(ContextCacheInsertSchema);
-createApiUpdateSchema(ContextCacheUpdateSchema);
-var DataComponentSelectSchema = createSelectSchema(dataComponents);
-var DataComponentInsertSchema = createInsertSchema(dataComponents).extend({
-  id: resourceIdSchema
-});
-DataComponentInsertSchema.omit({
-  createdAt: true,
-  updatedAt: true
-});
-var DataComponentUpdateSchema = DataComponentInsertSchema.partial();
-var DataComponentApiSelectSchema = createApiSchema(DataComponentSelectSchema).openapi("DataComponent");
-var DataComponentApiInsertSchema = createApiInsertSchema(DataComponentInsertSchema).openapi("DataComponentCreate");
-createApiUpdateSchema(DataComponentUpdateSchema).openapi("DataComponentUpdate");
-var SubAgentDataComponentSelectSchema = createSelectSchema(subAgentDataComponents);
-var SubAgentDataComponentInsertSchema = createInsertSchema(subAgentDataComponents);
-var SubAgentDataComponentUpdateSchema = SubAgentDataComponentInsertSchema.partial();
-var SubAgentDataComponentApiSelectSchema = createAgentScopedApiSchema(
-  SubAgentDataComponentSelectSchema
-);
-SubAgentDataComponentInsertSchema.omit({
-  tenantId: true,
-  projectId: true,
-  id: true,
-  createdAt: true
-});
-createAgentScopedApiUpdateSchema(
-  SubAgentDataComponentUpdateSchema
-);
-var ArtifactComponentSelectSchema = createSelectSchema(artifactComponents);
-var ArtifactComponentInsertSchema = createInsertSchema(artifactComponents).extend({
-  id: resourceIdSchema
-});
-var ArtifactComponentUpdateSchema = ArtifactComponentInsertSchema.partial();
-var ArtifactComponentApiSelectSchema = createApiSchema(
-  ArtifactComponentSelectSchema
-).openapi("ArtifactComponent");
-var ArtifactComponentApiInsertSchema = ArtifactComponentInsertSchema.omit({
-  tenantId: true,
-  projectId: true,
-  createdAt: true,
-  updatedAt: true
-}).openapi("ArtifactComponentCreate");
-createApiUpdateSchema(
-  ArtifactComponentUpdateSchema
-).openapi("ArtifactComponentUpdate");
-var SubAgentArtifactComponentSelectSchema = createSelectSchema(subAgentArtifactComponents);
-var SubAgentArtifactComponentInsertSchema = createInsertSchema(
-  subAgentArtifactComponents
-).extend({
-  id: resourceIdSchema,
-  subAgentId: resourceIdSchema,
-  artifactComponentId: resourceIdSchema
-});
-var SubAgentArtifactComponentUpdateSchema = SubAgentArtifactComponentInsertSchema.partial();
-var SubAgentArtifactComponentApiSelectSchema = createAgentScopedApiSchema(
-  SubAgentArtifactComponentSelectSchema
-);
-SubAgentArtifactComponentInsertSchema.omit({
-  tenantId: true,
-  projectId: true,
-  id: true,
-  createdAt: true
-});
-createAgentScopedApiUpdateSchema(
-  SubAgentArtifactComponentUpdateSchema
-);
-var ExternalAgentSelectSchema = createSelectSchema(externalAgents).extend({
-  credentialReferenceId: zodOpenapi.z.string().nullable().optional()
-});
-var ExternalAgentInsertSchema = createInsertSchema(externalAgents).extend({
-  id: resourceIdSchema
-});
-var ExternalAgentUpdateSchema = ExternalAgentInsertSchema.partial();
-var ExternalAgentApiSelectSchema = createApiSchema(ExternalAgentSelectSchema).openapi("ExternalAgent");
-var ExternalAgentApiInsertSchema = createApiInsertSchema(ExternalAgentInsertSchema).openapi("ExternalAgentCreate");
-createApiUpdateSchema(ExternalAgentUpdateSchema).openapi("ExternalAgentUpdate");
-zodOpenapi.z.discriminatedUnion("type", [
-  SubAgentApiSelectSchema.extend({ type: zodOpenapi.z.literal("internal") }),
-  ExternalAgentApiSelectSchema.extend({ type: zodOpenapi.z.literal("external") })
-]);
-var ApiKeySelectSchema = createSelectSchema(apiKeys);
-var ApiKeyInsertSchema = createInsertSchema(apiKeys).extend({
-  id: resourceIdSchema,
-  agentId: resourceIdSchema
-});
-var ApiKeyUpdateSchema = ApiKeyInsertSchema.partial().omit({
-  tenantId: true,
-  projectId: true,
-  id: true,
-  publicId: true,
-  keyHash: true,
-  keyPrefix: true,
-  createdAt: true
-});
-var ApiKeyApiSelectSchema = ApiKeySelectSchema.omit({
-  tenantId: true,
-  projectId: true,
-  keyHash: true
-  // Never expose the hash
-}).openapi("ApiKey");
-zodOpenapi.z.object({
-  data: zodOpenapi.z.object({
-    apiKey: ApiKeyApiSelectSchema,
-    key: zodOpenapi.z.string().describe("The full API key (shown only once)")
-  })
-});
-ApiKeyInsertSchema.omit({
-  tenantId: true,
-  projectId: true,
-  id: true,
-  // Auto-generated
-  publicId: true,
-  // Auto-generated
-  keyHash: true,
-  // Auto-generated
-  keyPrefix: true,
-  // Auto-generated
-  lastUsedAt: true
-  // Not set on creation
-}).openapi("ApiKeyCreate");
-ApiKeyUpdateSchema.openapi("ApiKeyUpdate");
-var CredentialReferenceSelectSchema = zodOpenapi.z.object({
-  id: zodOpenapi.z.string(),
-  tenantId: zodOpenapi.z.string(),
-  projectId: zodOpenapi.z.string(),
-  name: zodOpenapi.z.string(),
-  type: zodOpenapi.z.string(),
-  credentialStoreId: zodOpenapi.z.string(),
-  retrievalParams: zodOpenapi.z.record(zodOpenapi.z.string(), zodOpenapi.z.unknown()).nullish(),
-  createdAt: zodOpenapi.z.string(),
-  updatedAt: zodOpenapi.z.string()
-});
-var CredentialReferenceInsertSchema = createInsertSchema(credentialReferences).extend({
-  id: resourceIdSchema,
-  type: zodOpenapi.z.string(),
-  credentialStoreId: resourceIdSchema,
-  retrievalParams: zodOpenapi.z.record(zodOpenapi.z.string(), zodOpenapi.z.unknown()).nullish()
-});
-var CredentialReferenceUpdateSchema = CredentialReferenceInsertSchema.partial();
-var CredentialReferenceApiSelectSchema = createApiSchema(CredentialReferenceSelectSchema).extend({
-  type: zodOpenapi.z.enum(CredentialStoreType),
-  tools: zodOpenapi.z.array(ToolSelectSchema).optional(),
-  externalAgents: zodOpenapi.z.array(ExternalAgentSelectSchema).optional()
-}).openapi("CredentialReference");
-var CredentialReferenceApiInsertSchema = createApiInsertSchema(
-  CredentialReferenceInsertSchema
-).extend({
-  type: zodOpenapi.z.enum(CredentialStoreType)
-}).openapi("CredentialReferenceCreate");
-createApiUpdateSchema(
-  CredentialReferenceUpdateSchema
-).extend({
-  type: zodOpenapi.z.enum(CredentialStoreType).optional()
-}).openapi("CredentialReferenceUpdate");
-var CredentialStoreSchema = zodOpenapi.z.object({
-  id: zodOpenapi.z.string().describe("Unique identifier of the credential store"),
-  type: zodOpenapi.z.enum(CredentialStoreType),
-  available: zodOpenapi.z.boolean().describe("Whether the store is functional and ready to use"),
-  reason: zodOpenapi.z.string().nullable().describe("Reason why store is not available, if applicable")
-}).openapi("CredentialStore");
-zodOpenapi.z.object({
-  data: zodOpenapi.z.array(CredentialStoreSchema).describe("List of credential stores")
-}).openapi("CredentialStoreListResponse");
-zodOpenapi.z.object({
-  key: zodOpenapi.z.string().describe("The credential key"),
-  value: zodOpenapi.z.string().describe("The credential value"),
-  metadata: zodOpenapi.z.record(zodOpenapi.z.string(), zodOpenapi.z.string()).nullish().describe("The metadata for the credential")
-}).openapi("CreateCredentialInStoreRequest");
-zodOpenapi.z.object({
-  data: zodOpenapi.z.object({
-    key: zodOpenapi.z.string().describe("The credential key"),
-    storeId: zodOpenapi.z.string().describe("The store ID where credential was created"),
-    createdAt: zodOpenapi.z.string().describe("ISO timestamp of creation")
-  })
-}).openapi("CreateCredentialInStoreResponse");
-var RelatedAgentInfoSchema = zodOpenapi.z.object({
-  id: zodOpenapi.z.string(),
-  name: zodOpenapi.z.string(),
-  description: zodOpenapi.z.string()
-}).openapi("RelatedAgentInfo");
-var ComponentAssociationSchema = zodOpenapi.z.object({
-  subAgentId: zodOpenapi.z.string(),
-  createdAt: zodOpenapi.z.string()
-}).openapi("ComponentAssociation");
-zodOpenapi.z.object({
-  tenantId: zodOpenapi.z.string().min(1, "Tenant ID is required"),
-  projectId: zodOpenapi.z.string().min(1, "Project ID is required"),
-  toolId: zodOpenapi.z.string().min(1, "Tool ID is required")
-}).openapi("OAuthLoginQuery");
-zodOpenapi.z.object({
-  code: zodOpenapi.z.string().min(1, "Authorization code is required"),
-  state: zodOpenapi.z.string().min(1, "State parameter is required"),
-  error: zodOpenapi.z.string().optional(),
-  error_description: zodOpenapi.z.string().optional()
-}).openapi("OAuthCallbackQuery");
-var McpToolSchema = ToolInsertSchema.extend({
-  imageUrl: imageUrlSchema,
-  availableTools: zodOpenapi.z.array(McpToolDefinitionSchema).optional(),
-  status: ToolStatusSchema.default("unknown"),
-  version: zodOpenapi.z.string().optional(),
-  createdAt: zodOpenapi.z.date(),
-  updatedAt: zodOpenapi.z.date(),
-  expiresAt: zodOpenapi.z.date().optional(),
-  relationshipId: zodOpenapi.z.string().optional()
-}).openapi("McpTool");
-McpToolSchema.omit({
-  config: true,
-  tenantId: true,
-  projectId: true,
-  status: true,
-  version: true,
-  createdAt: true,
-  updatedAt: true,
-  credentialReferenceId: true
-}).extend({
-  tenantId: zodOpenapi.z.string().optional(),
-  projectId: zodOpenapi.z.string().optional(),
-  description: zodOpenapi.z.string().optional(),
-  serverUrl: zodOpenapi.z.url(),
-  activeTools: zodOpenapi.z.array(zodOpenapi.z.string()).optional(),
-  mcpType: zodOpenapi.z.enum(MCPServerType).optional(),
-  transport: McpTransportConfigSchema.optional(),
-  credential: CredentialReferenceApiInsertSchema.optional()
-});
-var ToolUpdateSchema = ToolInsertSchema.partial();
-var ToolApiSelectSchema = createApiSchema(ToolSelectSchema).openapi("Tool");
-var ToolApiInsertSchema = createApiInsertSchema(ToolInsertSchema).openapi("ToolCreate");
-createApiUpdateSchema(ToolUpdateSchema).openapi("ToolUpdate");
-var FunctionToolSelectSchema = createSelectSchema(functionTools);
-var FunctionToolInsertSchema = createInsertSchema(functionTools).extend({
-  id: resourceIdSchema
-});
-var FunctionToolUpdateSchema = FunctionToolInsertSchema.partial();
-var FunctionToolApiSelectSchema = createApiSchema(FunctionToolSelectSchema).openapi("FunctionTool");
-var FunctionToolApiInsertSchema = createAgentScopedApiInsertSchema(FunctionToolInsertSchema).openapi("FunctionToolCreate");
-createApiUpdateSchema(FunctionToolUpdateSchema).openapi("FunctionToolUpdate");
-var FunctionSelectSchema = createSelectSchema(functions);
-var FunctionInsertSchema = createInsertSchema(functions).extend({
-  id: resourceIdSchema
-});
-var FunctionUpdateSchema = FunctionInsertSchema.partial();
-var FunctionApiSelectSchema = createApiSchema(FunctionSelectSchema).openapi("Function");
-var FunctionApiInsertSchema = createApiInsertSchema(FunctionInsertSchema).openapi("FunctionCreate");
-var FunctionApiUpdateSchema = createApiUpdateSchema(FunctionUpdateSchema).openapi("FunctionUpdate");
-var FetchConfigSchema = zodOpenapi.z.object({
-  url: zodOpenapi.z.string().min(1, "URL is required"),
-  method: zodOpenapi.z.enum(["GET", "POST", "PUT", "DELETE", "PATCH"]).optional().default("GET"),
-  headers: zodOpenapi.z.record(zodOpenapi.z.string(), zodOpenapi.z.string()).optional(),
-  body: zodOpenapi.z.record(zodOpenapi.z.string(), zodOpenapi.z.unknown()).optional(),
-  transform: zodOpenapi.z.string().optional(),
-  // JSONPath or JS transform function
-  timeout: zodOpenapi.z.number().min(0).optional().default(CONTEXT_FETCHER_HTTP_TIMEOUT_MS_DEFAULT).optional()
-}).openapi("FetchConfig");
-zodOpenapi.z.object({
-  id: zodOpenapi.z.string().min(1, "Fetch definition ID is required"),
-  name: zodOpenapi.z.string().optional(),
-  trigger: zodOpenapi.z.enum(["initialization", "invocation"]),
-  fetchConfig: FetchConfigSchema,
-  responseSchema: zodOpenapi.z.any().optional(),
-  // JSON Schema for validating HTTP response
-  defaultValue: zodOpenapi.z.any().optional().openapi({
-    description: "Default value if fetch fails"
-  }),
-  credential: CredentialReferenceApiInsertSchema.optional()
-}).openapi("FetchDefinition");
-var ContextConfigSelectSchema = createSelectSchema(contextConfigs).extend({
-  headersSchema: zodOpenapi.z.any().optional().openapi({
-    type: "object",
-    description: "JSON Schema for validating request headers"
-  })
-});
-var ContextConfigInsertSchema = createInsertSchema(contextConfigs).extend({
-  id: resourceIdSchema.optional(),
-  headersSchema: zodOpenapi.z.any().nullable().optional().openapi({
-    type: "object",
-    description: "JSON Schema for validating request headers"
-  }),
-  contextVariables: zodOpenapi.z.any().nullable().optional().openapi({
-    type: "object",
-    description: "Context variables configuration with fetch definitions"
-  })
-}).omit({
-  createdAt: true,
-  updatedAt: true
-});
-var ContextConfigUpdateSchema = ContextConfigInsertSchema.partial();
-var ContextConfigApiSelectSchema = createApiSchema(ContextConfigSelectSchema).omit({
-  agentId: true
-}).openapi("ContextConfig");
-var ContextConfigApiInsertSchema = createApiInsertSchema(ContextConfigInsertSchema).omit({
-  agentId: true
-}).openapi("ContextConfigCreate");
-createApiUpdateSchema(ContextConfigUpdateSchema).omit({
-  agentId: true
-}).openapi("ContextConfigUpdate");
-var SubAgentToolRelationSelectSchema = createSelectSchema(subAgentToolRelations);
-var SubAgentToolRelationInsertSchema = createInsertSchema(subAgentToolRelations).extend({
-  id: resourceIdSchema,
-  subAgentId: resourceIdSchema,
-  toolId: resourceIdSchema,
-  selectedTools: zodOpenapi.z.array(zodOpenapi.z.string()).nullish(),
-  headers: zodOpenapi.z.record(zodOpenapi.z.string(), zodOpenapi.z.string()).nullish()
-});
-var SubAgentToolRelationUpdateSchema = SubAgentToolRelationInsertSchema.partial();
-var SubAgentToolRelationApiSelectSchema = createAgentScopedApiSchema(
-  SubAgentToolRelationSelectSchema
-).openapi("SubAgentToolRelation");
-createAgentScopedApiInsertSchema(
-  SubAgentToolRelationInsertSchema
-).openapi("SubAgentToolRelationCreate");
-createAgentScopedApiUpdateSchema(
-  SubAgentToolRelationUpdateSchema
-).openapi("SubAgentToolRelationUpdate");
-var SubAgentExternalAgentRelationSelectSchema = createSelectSchema(
-  subAgentExternalAgentRelations
-);
-var SubAgentExternalAgentRelationInsertSchema = createInsertSchema(
-  subAgentExternalAgentRelations
-).extend({
-  id: resourceIdSchema,
-  subAgentId: resourceIdSchema,
-  externalAgentId: resourceIdSchema,
-  headers: zodOpenapi.z.record(zodOpenapi.z.string(), zodOpenapi.z.string()).nullish()
-});
-var SubAgentExternalAgentRelationUpdateSchema = SubAgentExternalAgentRelationInsertSchema.partial();
-var SubAgentExternalAgentRelationApiSelectSchema = createAgentScopedApiSchema(
-  SubAgentExternalAgentRelationSelectSchema
-).openapi("SubAgentExternalAgentRelation");
-createAgentScopedApiInsertSchema(
-  SubAgentExternalAgentRelationInsertSchema
-).omit({ id: true, subAgentId: true }).openapi("SubAgentExternalAgentRelationCreate");
-createAgentScopedApiUpdateSchema(
-  SubAgentExternalAgentRelationUpdateSchema
-).openapi("SubAgentExternalAgentRelationUpdate");
-var SubAgentTeamAgentRelationSelectSchema = createSelectSchema(subAgentTeamAgentRelations);
-var SubAgentTeamAgentRelationInsertSchema = createInsertSchema(
-  subAgentTeamAgentRelations
-).extend({
-  id: resourceIdSchema,
-  subAgentId: resourceIdSchema,
-  targetAgentId: resourceIdSchema,
-  headers: zodOpenapi.z.record(zodOpenapi.z.string(), zodOpenapi.z.string()).nullish()
-});
-var SubAgentTeamAgentRelationUpdateSchema = SubAgentTeamAgentRelationInsertSchema.partial();
-var SubAgentTeamAgentRelationApiSelectSchema = createAgentScopedApiSchema(
-  SubAgentTeamAgentRelationSelectSchema
-).openapi("SubAgentTeamAgentRelation");
-createAgentScopedApiInsertSchema(
-  SubAgentTeamAgentRelationInsertSchema
-).omit({ id: true, subAgentId: true }).openapi("SubAgentTeamAgentRelationCreate");
-createAgentScopedApiUpdateSchema(
-  SubAgentTeamAgentRelationUpdateSchema
-).openapi("SubAgentTeamAgentRelationUpdate");
-var LedgerArtifactSelectSchema = createSelectSchema(ledgerArtifacts);
-var LedgerArtifactInsertSchema = createInsertSchema(ledgerArtifacts);
-var LedgerArtifactUpdateSchema = LedgerArtifactInsertSchema.partial();
-createApiSchema(LedgerArtifactSelectSchema);
-createApiInsertSchema(LedgerArtifactInsertSchema);
-createApiUpdateSchema(LedgerArtifactUpdateSchema);
-var StatusComponentSchema = zodOpenapi.z.object({
-  type: zodOpenapi.z.string(),
-  description: zodOpenapi.z.string().optional(),
-  detailsSchema: zodOpenapi.z.object({
-    type: zodOpenapi.z.literal("object"),
-    properties: zodOpenapi.z.record(zodOpenapi.z.string(), zodOpenapi.z.any()),
-    required: zodOpenapi.z.array(zodOpenapi.z.string()).optional()
-  }).optional()
-}).openapi("StatusComponent");
-var StatusUpdateSchema = zodOpenapi.z.object({
-  enabled: zodOpenapi.z.boolean().optional(),
-  numEvents: zodOpenapi.z.number().min(1).max(STATUS_UPDATE_MAX_NUM_EVENTS).optional(),
-  timeInSeconds: zodOpenapi.z.number().min(1).max(STATUS_UPDATE_MAX_INTERVAL_SECONDS).optional(),
-  prompt: zodOpenapi.z.string().max(
-    VALIDATION_SUB_AGENT_PROMPT_MAX_CHARS,
-    `Custom prompt cannot exceed ${VALIDATION_SUB_AGENT_PROMPT_MAX_CHARS} characters`
-  ).optional(),
-  statusComponents: zodOpenapi.z.array(StatusComponentSchema).optional()
-}).openapi("StatusUpdate");
-var CanUseItemSchema = zodOpenapi.z.object({
-  agentToolRelationId: zodOpenapi.z.string().optional(),
-  toolId: zodOpenapi.z.string(),
-  toolSelection: zodOpenapi.z.array(zodOpenapi.z.string()).nullish(),
-  headers: zodOpenapi.z.record(zodOpenapi.z.string(), zodOpenapi.z.string()).nullish()
-}).openapi("CanUseItem");
-var canDelegateToExternalAgentSchema = zodOpenapi.z.object({
-  externalAgentId: zodOpenapi.z.string(),
-  subAgentExternalAgentRelationId: zodOpenapi.z.string().optional(),
-  headers: zodOpenapi.z.record(zodOpenapi.z.string(), zodOpenapi.z.string()).nullish()
-}).openapi("CanDelegateToExternalAgent");
-var canDelegateToTeamAgentSchema = zodOpenapi.z.object({
-  agentId: zodOpenapi.z.string(),
-  subAgentTeamAgentRelationId: zodOpenapi.z.string().optional(),
-  headers: zodOpenapi.z.record(zodOpenapi.z.string(), zodOpenapi.z.string()).nullish()
-}).openapi("CanDelegateToTeamAgent");
-var TeamAgentSchema = zodOpenapi.z.object({
-  id: zodOpenapi.z.string(),
-  name: zodOpenapi.z.string(),
-  description: zodOpenapi.z.string()
-}).openapi("TeamAgent");
-var FullAgentAgentInsertSchema = SubAgentApiInsertSchema.extend({
-  type: zodOpenapi.z.literal("internal"),
-  canUse: zodOpenapi.z.array(CanUseItemSchema),
-  // All tools (both MCP and function tools)
-  dataComponents: zodOpenapi.z.array(zodOpenapi.z.string()).optional(),
-  artifactComponents: zodOpenapi.z.array(zodOpenapi.z.string()).optional(),
-  canTransferTo: zodOpenapi.z.array(zodOpenapi.z.string()).optional(),
-  prompt: zodOpenapi.z.string().trim().nonempty(),
-  canDelegateTo: zodOpenapi.z.array(
-    zodOpenapi.z.union([
-      zodOpenapi.z.string(),
-      // Internal subAgent ID
-      canDelegateToExternalAgentSchema,
-      // External agent with headers
-      canDelegateToTeamAgentSchema
-      // Team agent with headers
-    ])
-  ).optional()
-}).openapi("FullAgentAgentInsert");
-var AgentWithinContextOfProjectSchema = AgentApiInsertSchema.extend({
-  subAgents: zodOpenapi.z.record(zodOpenapi.z.string(), FullAgentAgentInsertSchema),
-  // Lookup maps for UI to resolve canUse items
-  tools: zodOpenapi.z.record(zodOpenapi.z.string(), ToolApiInsertSchema).optional(),
-  // MCP tools (project-scoped)
-  externalAgents: zodOpenapi.z.record(zodOpenapi.z.string(), ExternalAgentApiInsertSchema).optional(),
-  // External agents (project-scoped)
-  teamAgents: zodOpenapi.z.record(zodOpenapi.z.string(), TeamAgentSchema).optional(),
-  // Team agents contain basic metadata for the agent to be delegated to
-  functionTools: zodOpenapi.z.record(zodOpenapi.z.string(), FunctionToolApiInsertSchema).optional(),
-  // Function tools (agent-scoped)
-  functions: zodOpenapi.z.record(zodOpenapi.z.string(), FunctionApiInsertSchema).optional(),
-  // Get function code for function tools
-  contextConfig: zodOpenapi.z.optional(ContextConfigApiInsertSchema),
-  statusUpdates: zodOpenapi.z.optional(StatusUpdateSchema),
-  models: ModelSchema.optional(),
-  stopWhen: AgentStopWhenSchema.optional(),
-  prompt: zodOpenapi.z.string().max(
-    VALIDATION_AGENT_PROMPT_MAX_CHARS,
-    `Agent prompt cannot exceed ${VALIDATION_AGENT_PROMPT_MAX_CHARS} characters`
-  ).optional()
-}).openapi("AgentWithinContextOfProject");
-var PaginationSchema = zodOpenapi.z.object({
-  page: pageNumber,
-  limit: limitNumber,
-  total: zodOpenapi.z.number(),
-  pages: zodOpenapi.z.number()
-}).openapi("Pagination");
-zodOpenapi.z.object({
-  error: zodOpenapi.z.string(),
-  message: zodOpenapi.z.string().optional(),
-  details: zodOpenapi.z.any().optional().openapi({
-    description: "Additional error details"
-  })
-}).openapi("ErrorResponse");
-zodOpenapi.z.object({
-  exists: zodOpenapi.z.boolean()
-}).openapi("ExistsResponse");
-zodOpenapi.z.object({
-  message: zodOpenapi.z.string(),
-  removed: zodOpenapi.z.boolean()
-}).openapi("RemovedResponse");
-var ProjectSelectSchema = registerFieldSchemas(
-  createSelectSchema(projects).extend({
-    models: ProjectModelSchema.nullable(),
-    stopWhen: StopWhenSchema.nullable()
-  })
-);
-var ProjectInsertSchema = createInsertSchema(projects).extend({
-  models: ProjectModelSchema,
-  stopWhen: StopWhenSchema.optional()
-}).omit({
-  createdAt: true,
-  updatedAt: true
-});
-var ProjectUpdateSchema = ProjectInsertSchema.partial().omit({
-  id: true,
-  tenantId: true
-});
-var ProjectApiSelectSchema = ProjectSelectSchema.omit({ tenantId: true }).openapi(
-  "Project"
-);
-var ProjectApiInsertSchema = ProjectInsertSchema.omit({ tenantId: true }).openapi(
-  "ProjectCreate"
-);
-ProjectUpdateSchema.openapi("ProjectUpdate");
-var FullProjectDefinitionSchema = ProjectApiInsertSchema.extend({
-  agents: zodOpenapi.z.record(zodOpenapi.z.string(), AgentWithinContextOfProjectSchema),
-  tools: zodOpenapi.z.record(zodOpenapi.z.string(), ToolApiInsertSchema),
-  functionTools: zodOpenapi.z.record(zodOpenapi.z.string(), FunctionToolApiInsertSchema).optional(),
-  functions: zodOpenapi.z.record(zodOpenapi.z.string(), FunctionApiInsertSchema).optional(),
-  dataComponents: zodOpenapi.z.record(zodOpenapi.z.string(), DataComponentApiInsertSchema).optional(),
-  artifactComponents: zodOpenapi.z.record(zodOpenapi.z.string(), ArtifactComponentApiInsertSchema).optional(),
-  externalAgents: zodOpenapi.z.record(zodOpenapi.z.string(), ExternalAgentApiInsertSchema).optional(),
-  statusUpdates: zodOpenapi.z.optional(StatusUpdateSchema),
-  credentialReferences: zodOpenapi.z.record(zodOpenapi.z.string(), CredentialReferenceApiInsertSchema).optional(),
-  createdAt: zodOpenapi.z.string().optional(),
-  updatedAt: zodOpenapi.z.string().optional()
-}).openapi("FullProjectDefinition");
-zodOpenapi.z.object({ data: ProjectApiSelectSchema }).openapi("ProjectResponse");
-zodOpenapi.z.object({ data: SubAgentApiSelectSchema }).openapi("SubAgentResponse");
-zodOpenapi.z.object({ data: AgentApiSelectSchema }).openapi("AgentResponse");
-zodOpenapi.z.object({ data: ToolApiSelectSchema }).openapi("ToolResponse");
-zodOpenapi.z.object({ data: ExternalAgentApiSelectSchema }).openapi("ExternalAgentResponse");
-zodOpenapi.z.object({ data: ContextConfigApiSelectSchema }).openapi("ContextConfigResponse");
-zodOpenapi.z.object({ data: ApiKeyApiSelectSchema }).openapi("ApiKeyResponse");
-zodOpenapi.z.object({ data: CredentialReferenceApiSelectSchema }).openapi("CredentialReferenceResponse");
-zodOpenapi.z.object({ data: FunctionApiSelectSchema }).openapi("FunctionResponse");
-zodOpenapi.z.object({ data: FunctionToolApiSelectSchema }).openapi("FunctionToolResponse");
-zodOpenapi.z.object({ data: DataComponentApiSelectSchema }).openapi("DataComponentResponse");
-zodOpenapi.z.object({ data: ArtifactComponentApiSelectSchema }).openapi("ArtifactComponentResponse");
-zodOpenapi.z.object({ data: SubAgentRelationApiSelectSchema }).openapi("SubAgentRelationResponse");
-zodOpenapi.z.object({ data: SubAgentToolRelationApiSelectSchema }).openapi("SubAgentToolRelationResponse");
-zodOpenapi.z.object({ data: ConversationApiSelectSchema }).openapi("ConversationResponse");
-zodOpenapi.z.object({ data: MessageApiSelectSchema }).openapi("MessageResponse");
-zodOpenapi.z.object({
-  data: zodOpenapi.z.array(ProjectApiSelectSchema),
-  pagination: PaginationSchema
-}).openapi("ProjectListResponse");
-zodOpenapi.z.object({
-  data: zodOpenapi.z.array(SubAgentApiSelectSchema),
-  pagination: PaginationSchema
-}).openapi("SubAgentListResponse");
-zodOpenapi.z.object({
-  data: zodOpenapi.z.array(AgentApiSelectSchema),
-  pagination: PaginationSchema
-}).openapi("AgentListResponse");
-zodOpenapi.z.object({
-  data: zodOpenapi.z.array(ToolApiSelectSchema),
-  pagination: PaginationSchema
-}).openapi("ToolListResponse");
-zodOpenapi.z.object({
-  data: zodOpenapi.z.array(ExternalAgentApiSelectSchema),
-  pagination: PaginationSchema
-}).openapi("ExternalAgentListResponse");
-zodOpenapi.z.object({
-  data: zodOpenapi.z.array(ContextConfigApiSelectSchema),
-  pagination: PaginationSchema
-}).openapi("ContextConfigListResponse");
-zodOpenapi.z.object({
-  data: zodOpenapi.z.array(ApiKeyApiSelectSchema),
-  pagination: PaginationSchema
-}).openapi("ApiKeyListResponse");
-zodOpenapi.z.object({
-  data: zodOpenapi.z.array(CredentialReferenceApiSelectSchema),
-  pagination: PaginationSchema
-}).openapi("CredentialReferenceListResponse");
-zodOpenapi.z.object({
-  data: zodOpenapi.z.array(FunctionApiSelectSchema),
-  pagination: PaginationSchema
-}).openapi("FunctionListResponse");
-zodOpenapi.z.object({
-  data: zodOpenapi.z.array(FunctionToolApiSelectSchema),
-  pagination: PaginationSchema
-}).openapi("FunctionToolListResponse");
-zodOpenapi.z.object({
-  data: zodOpenapi.z.array(DataComponentApiSelectSchema),
-  pagination: PaginationSchema
-}).openapi("DataComponentListResponse");
-zodOpenapi.z.object({
-  data: zodOpenapi.z.array(ArtifactComponentApiSelectSchema),
-  pagination: PaginationSchema
-}).openapi("ArtifactComponentListResponse");
-zodOpenapi.z.object({
-  data: zodOpenapi.z.array(SubAgentRelationApiSelectSchema),
-  pagination: PaginationSchema
-}).openapi("SubAgentRelationListResponse");
-zodOpenapi.z.object({
-  data: zodOpenapi.z.array(SubAgentToolRelationApiSelectSchema),
-  pagination: PaginationSchema
-}).openapi("SubAgentToolRelationListResponse");
-zodOpenapi.z.object({
-  data: zodOpenapi.z.array(ConversationApiSelectSchema),
-  pagination: PaginationSchema
-}).openapi("ConversationListResponse");
-zodOpenapi.z.object({
-  data: zodOpenapi.z.array(MessageApiSelectSchema),
-  pagination: PaginationSchema
-}).openapi("MessageListResponse");
-zodOpenapi.z.object({ data: SubAgentDataComponentApiSelectSchema }).openapi("SubAgentDataComponentResponse");
-zodOpenapi.z.object({ data: SubAgentArtifactComponentApiSelectSchema }).openapi("SubAgentArtifactComponentResponse");
-zodOpenapi.z.object({
-  data: zodOpenapi.z.array(SubAgentDataComponentApiSelectSchema),
-  pagination: PaginationSchema
-}).openapi("SubAgentDataComponentListResponse");
-zodOpenapi.z.object({
-  data: zodOpenapi.z.array(SubAgentArtifactComponentApiSelectSchema),
-  pagination: PaginationSchema
-}).openapi("SubAgentArtifactComponentListResponse");
-zodOpenapi.z.object({ data: FullProjectDefinitionSchema }).openapi("FullProjectDefinitionResponse");
-zodOpenapi.z.object({ data: AgentWithinContextOfProjectSchema }).openapi("AgentWithinContextOfProjectResponse");
-zodOpenapi.z.object({
-  data: zodOpenapi.z.array(RelatedAgentInfoSchema),
-  pagination: PaginationSchema
-}).openapi("RelatedAgentInfoListResponse");
-zodOpenapi.z.object({ data: zodOpenapi.z.array(ComponentAssociationSchema) }).openapi("ComponentAssociationListResponse");
-zodOpenapi.z.object({ data: McpToolSchema }).openapi("McpToolResponse");
-zodOpenapi.z.object({
-  data: zodOpenapi.z.array(McpToolSchema),
-  pagination: PaginationSchema
-}).openapi("McpToolListResponse");
-zodOpenapi.z.object({ data: SubAgentTeamAgentRelationApiSelectSchema }).openapi("SubAgentTeamAgentRelationResponse");
-zodOpenapi.z.object({
-  data: zodOpenapi.z.array(SubAgentTeamAgentRelationApiSelectSchema),
-  pagination: PaginationSchema
-}).openapi("SubAgentTeamAgentRelationListResponse");
-zodOpenapi.z.object({ data: SubAgentExternalAgentRelationApiSelectSchema }).openapi("SubAgentExternalAgentRelationResponse");
-zodOpenapi.z.object({
-  data: zodOpenapi.z.array(SubAgentExternalAgentRelationApiSelectSchema),
-  pagination: PaginationSchema
-}).openapi("SubAgentExternalAgentRelationListResponse");
-zodOpenapi.z.object({ data: zodOpenapi.z.array(DataComponentApiSelectSchema) }).openapi("DataComponentArrayResponse");
-zodOpenapi.z.object({ data: zodOpenapi.z.array(ArtifactComponentApiSelectSchema) }).openapi("ArtifactComponentArrayResponse");
-zodOpenapi.z.object({
-  "x-inkeep-tenant-id": zodOpenapi.z.string().optional().openapi({
-    description: "Tenant identifier",
-    example: "tenant_123"
-  }),
-  "x-inkeep-project-id": zodOpenapi.z.string().optional().openapi({
-    description: "Project identifier",
-    example: "project_456"
-  }),
-  "x-inkeep-agent-id": zodOpenapi.z.string().optional().openapi({
-    description: "Agent identifier",
-    example: "agent_789"
-  })
-});
-var TenantId = zodOpenapi.z.string().openapi("TenantIdPathParam", {
-  param: {
-    name: "tenantId",
-    in: "path"
-  },
-  description: "Tenant identifier",
-  example: "tenant_123"
-});
-var ProjectId = zodOpenapi.z.string().openapi("ProjectIdPathParam", {
-  param: {
-    name: "projectId",
-    in: "path"
-  },
-  description: "Project identifier",
-  example: "project_456"
-});
-var AgentId = zodOpenapi.z.string().openapi("AgentIdPathParam", {
-  param: {
-    name: "agentId",
-    in: "path"
-  },
-  description: "Agent identifier",
-  example: "agent_789"
-});
-var SubAgentId = zodOpenapi.z.string().openapi("SubAgentIdPathParam", {
-  param: {
-    name: "subAgentId",
-    in: "path"
-  },
-  description: "Sub-agent identifier",
-  example: "sub_agent_123"
-});
-var TenantParamsSchema = zodOpenapi.z.object({
-  tenantId: TenantId
-});
-TenantParamsSchema.extend({
-  id: resourceIdSchema
-});
-var TenantProjectParamsSchema = TenantParamsSchema.extend({
-  projectId: ProjectId
-});
-TenantProjectParamsSchema.extend({
-  id: resourceIdSchema
-});
-var TenantProjectAgentParamsSchema = TenantProjectParamsSchema.extend({
-  agentId: AgentId
-});
-TenantProjectAgentParamsSchema.extend({
-  id: resourceIdSchema
-});
-var TenantProjectAgentSubAgentParamsSchema = TenantProjectAgentParamsSchema.extend({
-  subAgentId: SubAgentId
-});
-TenantProjectAgentSubAgentParamsSchema.extend({
-  id: resourceIdSchema
-});
-zodOpenapi.z.object({
-  page: pageNumber,
-  limit: limitNumber
-}).openapi("PaginationQueryParams");
-function validatePropsAsJsonSchema(props) {
-  if (!props || typeof props === "object" && Object.keys(props).length === 0) {
-    return {
-      isValid: true,
-      errors: []
-    };
-  }
-  if (typeof props !== "object" || Array.isArray(props)) {
-    return {
-      isValid: false,
-      errors: [
-        {
-          field: "props",
-          message: "Props must be a valid JSON Schema object",
-          value: props
-        }
-      ]
-    };
-  }
-  if (!props.type) {
-    return {
-      isValid: false,
-      errors: [
-        {
-          field: "props.type",
-          message: 'JSON Schema must have a "type" field'
-        }
-      ]
-    };
-  }
-  if (props.type !== "object") {
-    return {
-      isValid: false,
-      errors: [
-        {
-          field: "props.type",
-          message: 'JSON Schema type must be "object" for component props',
-          value: props.type
-        }
-      ]
-    };
-  }
-  if (!props.properties || typeof props.properties !== "object") {
-    return {
-      isValid: false,
-      errors: [
-        {
-          field: "props.properties",
-          message: 'JSON Schema must have a "properties" object'
-        }
-      ]
-    };
-  }
-  if (props.required !== void 0 && !Array.isArray(props.required)) {
-    return {
-      isValid: false,
-      errors: [
-        {
-          field: "props.required",
-          message: 'If present, "required" must be an array'
-        }
-      ]
-    };
-  }
-  try {
-    const schemaToValidate = { ...props };
-    delete schemaToValidate.$schema;
-    const schemaValidator = new Ajv__default.default({
-      strict: false,
-      // Allow unknown keywords like inPreview
-      validateSchema: true,
-      // Validate the schema itself
-      addUsedSchema: false
-      // Don't add schemas to the instance
-    });
-    const isValid = schemaValidator.validateSchema(schemaToValidate);
-    if (!isValid) {
-      const errors = schemaValidator.errors || [];
-      return {
-        isValid: false,
-        errors: errors.map((error) => ({
-          field: `props${error.instancePath || ""}`,
-          message: error.message || "Invalid schema"
-        }))
-      };
-    }
-    return {
-      isValid: true,
-      errors: []
-    };
-  } catch (error) {
-    return {
-      isValid: false,
-      errors: [
-        {
-          field: "props",
-          message: `Schema validation failed: ${error instanceof Error ? error.message : "Unknown error"}`
-        }
-      ]
-    };
-  }
-}
-
-// src/constants/otel-attributes.ts
-var DELEGATION_FROM_SUB_AGENT_ID = "delegation.from_sub_agent_id";
-var DELEGATION_TO_SUB_AGENT_ID = "delegation.to_sub_agent_id";
-var DELEGATION_ID = "delegation.id";
-var TRANSFER_FROM_SUB_AGENT_ID = "transfer.from_sub_agent_id";
-var TRANSFER_TO_SUB_AGENT_ID = "transfer.to_sub_agent_id";
-var SPAN_NAMES = {
-  AI_TOOL_CALL: "ai.toolCall",
-  CONTEXT_RESOLUTION: "context-resolver.resolve_single_fetch_definition",
-  CONTEXT_HANDLE: "context.handle_context_resolution",
-  AGENT_GENERATION: "agent.generate",
-  CONTEXT_FETCHER: "context-fetcher.http-request",
-  ARTIFACT_PROCESSING: "agent_session.process_artifact"
-};
-var AI_OPERATIONS = {
-  GENERATE_TEXT: "ai.generateText.doGenerate",
-  STREAM_TEXT: "ai.streamText.doStream",
-  STREAM_OBJECT: "ai.streamObject.doStream"
-};
-var SPAN_KEYS = {
-  // Core span attributes
-  SPAN_ID: "spanID",
-  TRACE_ID: "traceID",
-  DURATION_NANO: "durationNano",
-  TIMESTAMP: "timestamp",
-  HAS_ERROR: "hasError",
-  STATUS_MESSAGE: "status_message",
-  OTEL_STATUS_CODE: "otel.status_code",
-  OTEL_STATUS_DESCRIPTION: "otel.status_description",
-  // Agent attributesa
-  AGENT_ID: "agent.id",
-  AGENT_NAME: "agent.name",
-  TENANT_ID: "tenant.id",
-  PROJECT_ID: "project.id",
-  SUB_AGENT_NAME: "subAgent.name",
-  SUB_AGENT_ID: "subAgent.id",
-  // AI/Agent attributes
-  AI_OPERATION_ID: "ai.operationId",
-  AI_RESPONSE_TIMESTAMP: "ai.response.timestamp",
-  AI_RESPONSE_CONTENT: "ai.response.content",
-  AI_RESPONSE_TEXT: "ai.response.text",
-  AI_RESPONSE_OBJECT: "ai.response.object",
-  AI_RESPONSE_MODEL: "ai.response.model",
-  AI_RESPONSE_TOOL_CALLS: "ai.response.toolCalls",
-  AI_PROMPT_MESSAGES: "ai.prompt.messages",
-  AI_MODEL_PROVIDER: "ai.model.provider",
-  AI_TELEMETRY_FUNCTION_ID: "ai.telemetry.functionId",
-  AI_TELEMETRY_SUB_AGENT_ID: "ai.telemetry.metadata.subAgentId",
-  AI_TELEMETRY_SUB_AGENT_NAME: "ai.telemetry.metadata.subAgentName",
-  AI_MODEL_ID: "ai.model.id",
-  // Tool attributes
-  AI_TOOL_CALL_NAME: "ai.toolCall.name",
-  AI_TOOL_CALL_RESULT: "ai.toolCall.result",
-  AI_TOOL_CALL_ARGS: "ai.toolCall.args",
-  AI_TOOL_CALL_ID: "ai.toolCall.id",
-  AI_TOOL_TYPE: "ai.toolType",
-  TOOL_PURPOSE: "tool.purpose",
-  // Token usage
-  GEN_AI_USAGE_INPUT_TOKENS: "gen_ai.usage.input_tokens",
-  GEN_AI_USAGE_OUTPUT_TOKENS: "gen_ai.usage.output_tokens",
-  // Context attributes
-  CONTEXT_URL: "context.url",
-  CONTEXT_CONFIG_ID: "context.context_config_id",
-  CONTEXT_AGENT_ID: "context.agent_id",
-  CONTEXT_HEADERS_KEYS: "context.headers_keys",
-  // Message attributes
-  MESSAGE_CONTENT: "message.content",
-  MESSAGE_TIMESTAMP: "message.timestamp",
-  MCP_TOOL_DESCRIPTION: "mcp.tool.description",
-  // Delegation/Transfer attributes
-  DELEGATION_FROM_SUB_AGENT_ID,
-  DELEGATION_TO_SUB_AGENT_ID,
-  DELEGATION_ID,
-  TRANSFER_FROM_SUB_AGENT_ID,
-  TRANSFER_TO_SUB_AGENT_ID,
-  // HTTP attributes
-  HTTP_URL: "http.url",
-  HTTP_STATUS_CODE: "http.status_code",
-  HTTP_RESPONSE_BODY_SIZE: "http.response.body_size",
-  // Core attributes
-  NAME: "name",
-  PARENT_SPAN_ID: "parentSpanID",
-  CONVERSATION_ID: "conversation.id",
-  // Artifact processing attributes
-  ARTIFACT_ID: "artifact.id",
-  ARTIFACT_TYPE: "artifact.type",
-  ARTIFACT_TOOL_CALL_ID: "artifact.tool_call_id",
-  ARTIFACT_DATA: "artifact.data",
-  ARTIFACT_NAME: "artifact.name",
-  ARTIFACT_DESCRIPTION: "artifact.description"
-};
-var UNKNOWN_VALUE = "unknown";
-var ACTIVITY_TYPES = {
-  TOOL_CALL: "tool_call",
-  AI_GENERATION: "ai_generation",
-  AGENT_GENERATION: "agent_generation",
-  CONTEXT_FETCH: "context_fetch",
-  CONTEXT_RESOLUTION: "context_resolution",
-  USER_MESSAGE: "user_message",
-  AI_ASSISTANT_MESSAGE: "ai_assistant_message",
-  AI_MODEL_STREAMED_TEXT: "ai_model_streamed_text",
-  AI_MODEL_STREAMED_OBJECT: "ai_model_streamed_object"
-};
-var ACTIVITY_STATUS = {
-  SUCCESS: "success",
-  ERROR: "error",
-  PENDING: "pending"
-};
-var AGENT_IDS = {
-  USER: "user",
-  AI_ASSISTANT: "ai-assistant"
-};
-var ACTIVITY_NAMES = {
-  CONTEXT_FETCH: "Context Fetch",
-  USER_MESSAGE: "User Message",
-  AI_ASSISTANT_MESSAGE: "AI Assistant Message",
-  AI_TEXT_GENERATION: "AI Text Generation",
-  AI_STREAMING_TEXT: "AI Streaming Text",
-  AI_STREAMING_OBJECT: "AI Streaming Object",
-  UNKNOWN_AGENT: "Unknown Agent",
-  USER: "User"
-};
-var AI_TOOL_TYPES = {
-  MCP: "mcp",
-  TRANSFER: "transfer",
-  DELEGATION: "delegation"
-};
-
-// src/constants/signoz-queries.ts
-var DATA_TYPES = {
-  STRING: "string",
-  INT64: "int64",
-  FLOAT64: "float64",
-  BOOL: "bool"
-};
-var FIELD_TYPES = {
-  TAG: "tag",
-  RESOURCE: "resource"
-};
-var QUERY_FIELD_CONFIGS = {
-  // String tag fields
-  STRING_TAG: {
-    dataType: DATA_TYPES.STRING,
-    type: FIELD_TYPES.TAG,
-    isColumn: false
-  },
-  STRING_TAG_COLUMN: {
-    dataType: DATA_TYPES.STRING,
-    type: FIELD_TYPES.TAG,
-    isColumn: true
-  },
-  // Numeric tag fields
-  INT64_TAG: {
-    dataType: DATA_TYPES.INT64,
-    type: FIELD_TYPES.TAG,
-    isColumn: false
-  },
-  INT64_TAG_COLUMN: {
-    dataType: DATA_TYPES.INT64,
-    type: FIELD_TYPES.TAG,
-    isColumn: true
-  },
-  FLOAT64_TAG: {
-    dataType: DATA_TYPES.FLOAT64,
-    type: FIELD_TYPES.TAG,
-    isColumn: false
-  },
-  FLOAT64_TAG_COLUMN: {
-    dataType: DATA_TYPES.FLOAT64,
-    type: FIELD_TYPES.TAG,
-    isColumn: true
-  },
-  // Boolean tag fields
-  BOOL_TAG: {
-    dataType: DATA_TYPES.BOOL,
-    type: FIELD_TYPES.TAG,
-    isColumn: false
-  },
-  BOOL_TAG_COLUMN: {
-    dataType: DATA_TYPES.BOOL,
-    type: FIELD_TYPES.TAG,
-    isColumn: true
-  }
-};
-var OPERATORS = {
-  // Comparison operators
-  EQUALS: "=",
-  NOT_EQUALS: "!=",
-  LESS_THAN: "<",
-  GREATER_THAN: ">",
-  LESS_THAN_OR_EQUAL: "<=",
-  GREATER_THAN_OR_EQUAL: ">=",
-  // String operators
-  LIKE: "like",
-  NOT_LIKE: "nlike",
-  // Existence operators
-  EXISTS: "exists",
-  NOT_EXISTS: "nexists",
-  // Set operators
-  IN: "in",
-  NOT_IN: "nin",
-  // Logical operators
-  AND: "AND",
-  OR: "OR"
-};
-var QUERY_EXPRESSIONS = {
-  SPAN_NAMES: "spanNames",
-  AGENT_MODEL_CALLS: "agentModelCalls",
-  MODEL_CALLS: "modelCalls",
-  LAST_ACTIVITY: "lastActivity",
-  CONVERSATION_METADATA: "conversationMetadata",
-  FILTERED_CONVERSATIONS: "filteredConversations",
-  TOOLS: "tools",
-  TRANSFERS: "transfers",
-  DELEGATIONS: "delegations",
-  AI_CALLS: "aiCalls",
-  CONTEXT_ERRORS: "contextErrors",
-  AGENT_GENERATION_ERRORS: "agentGenerationErrors",
-  USER_MESSAGES: "userMessages",
-  UNIQUE_AGENTS: "uniqueAgents",
-  UNIQUE_MODELS: "uniqueModels",
-  // Route-specific query names
-  TOOL_CALLS: "toolCalls",
-  CONTEXT_RESOLUTION: "contextResolution",
-  CONTEXT_HANDLE: "contextHandle",
-  AI_ASSISTANT_MESSAGES: "aiAssistantMessages",
-  AI_GENERATIONS: "aiGenerations",
-  AI_STREAMING_TEXT: "aiStreamingText",
-  AI_STREAMING_OBJECT: "aiStreamingObject",
-  CONTEXT_FETCHERS: "contextFetchers",
-  DURATION_SPANS: "durationSpans",
-  AGENT_GENERATIONS: "agentGenerations",
-  SPANS_WITH_ERRORS: "spansWithErrors",
-  ARTIFACT_PROCESSING: "artifactProcessing"
-};
-var REDUCE_OPERATIONS = {
-  SUM: "sum",
-  MAX: "max",
-  MIN: "min",
-  AVG: "avg",
-  COUNT: "count"
-};
-var ORDER_DIRECTIONS = {
-  ASC: "asc",
-  DESC: "desc"
-};
-var QUERY_TYPES = {
-  BUILDER: "builder",
-  CLICKHOUSE: "clickhouse",
-  PROMQL: "promql"
-};
-var PANEL_TYPES = {
-  LIST: "list",
-  TABLE: "table",
-  AGENT: "agent",
-  VALUE: "value"
-};
-var DATA_SOURCES = {
-  TRACES: "traces",
-  METRICS: "metrics",
-  LOGS: "logs"
-};
-var AGGREGATE_OPERATORS = {
-  COUNT: "count",
-  COUNT_DISTINCT: "count_distinct",
-  SUM: "sum",
-  AVG: "avg",
-  MIN: "min",
-  MAX: "max",
-  NOOP: "noop"
-};
-var QUERY_DEFAULTS = {
-  STEP: 60,
-  STEP_INTERVAL: 60,
-  OFFSET: 0,
-  DISABLED: false,
-  HAVING: [],
-  LEGEND: "",
-  LIMIT_UNLIMITED: 1e4,
-  EMPTY_GROUP_BY: []
-};
-function discoverScopes(resourceMetadata, metadata) {
-  const resourceScopes = resourceMetadata?.scopes_supported;
-  const oauthScopes = metadata?.scopes_supported;
-  const scopes = (resourceScopes?.length ? resourceScopes : oauthScopes) || [];
-  return scopes.length > 0 ? scopes.join(" ") : void 0;
-}
-async function discoverMcpMetadata(mcpServerUrl, logger) {
-  try {
-    let resourceMetadata = null;
-    let authServerUrl = new URL(mcpServerUrl);
-    try {
-      resourceMetadata = await auth_js.discoverOAuthProtectedResourceMetadata(mcpServerUrl);
-      if (resourceMetadata?.authorization_servers?.length && resourceMetadata.authorization_servers[0]) {
-        authServerUrl = new URL(resourceMetadata.authorization_servers[0]);
-      }
-    } catch {
-    }
-    const metadata = await auth_js.discoverAuthorizationServerMetadata(authServerUrl.href);
-    if (!metadata) {
-      throw new Error("Failed to discover OAuth authorization server metadata");
-    }
-    logger?.debug(
-      {
-        tokenEndpoint: metadata.token_endpoint,
-        authEndpoint: metadata.authorization_endpoint
-      },
-      "MCP metadata discovery successful"
-    );
-    const discoveredScopes = discoverScopes(resourceMetadata ?? void 0, metadata);
-    return {
-      success: true,
-      metadata,
-      ...resourceMetadata && { resourceMetadata },
-      ...discoveredScopes && { scopes: discoveredScopes }
-    };
-  } catch (err) {
-    const errorMessage = err instanceof Error ? err.message : String(err);
-    logger?.debug({ error: errorMessage }, "MCP metadata discovery failed");
-    return { success: false, error: errorMessage };
-  }
-}
-var detectAuthenticationRequired = async ({
-  serverUrl,
-  error,
-  logger
-}) => {
-  try {
-    const discoveryResult = await discoverMcpMetadata(serverUrl, logger);
-    if (discoveryResult.success && discoveryResult.metadata) {
-      logger?.info({ serverUrl }, "MCP OAuth support confirmed via metadata discovery");
-      return true;
-    }
-  } catch (discoveryError) {
-    logger?.debug({ discoveryError }, "MCP OAuth metadata discovery failed");
-  }
-  logger?.debug({ error: error?.message }, "No MCP OAuth authentication requirement detected");
-  return false;
-};
-
-// src/client-exports.ts
-var {
-  AGENT_EXECUTION_TRANSFER_COUNT_MAX: AGENT_EXECUTION_TRANSFER_COUNT_MAX2,
-  AGENT_EXECUTION_TRANSFER_COUNT_MIN: AGENT_EXECUTION_TRANSFER_COUNT_MIN2,
-  STATUS_UPDATE_MAX_INTERVAL_SECONDS: STATUS_UPDATE_MAX_INTERVAL_SECONDS2,
-  STATUS_UPDATE_MAX_NUM_EVENTS: STATUS_UPDATE_MAX_NUM_EVENTS2,
-  VALIDATION_AGENT_PROMPT_MAX_CHARS: VALIDATION_AGENT_PROMPT_MAX_CHARS2,
-  VALIDATION_SUB_AGENT_PROMPT_MAX_CHARS: VALIDATION_SUB_AGENT_PROMPT_MAX_CHARS2
-} = schemaValidationDefaults;
-var TenantParamsSchema2 = zod.z.object({
-  tenantId: zod.z.string()
-});
-var TenantProjectParamsSchema2 = TenantParamsSchema2.extend({
-  projectId: zod.z.string()
-});
-var TenantProjectIdParamsSchema2 = TenantProjectParamsSchema2.extend({
-  id: zod.z.string()
-});
-var IdParamsSchema = zod.z.object({
-  id: zod.z.string()
-});
-var PaginationSchema2 = zod.z.object({
-  page: zod.z.coerce.number().min(1).default(1),
-  limit: zod.z.coerce.number().min(1).max(100).default(10),
-  total: zod.z.number(),
-  pages: zod.z.number()
-});
-var ListResponseSchema = (itemSchema) => zod.z.object({
-  data: zod.z.array(itemSchema),
-  pagination: PaginationSchema2
-});
-var SingleResponseSchema = (itemSchema) => zod.z.object({
-  data: itemSchema
-});
-var ErrorResponseSchema2 = zod.z.object({
-  error: zod.z.string(),
-  message: zod.z.string().optional(),
-  details: zod.z.unknown().optional()
-});
-var AgentApiInsertSchema2 = zod.z.object({
-  id: zod.z.string().optional(),
-  name: zod.z.string(),
-  description: zod.z.string().optional(),
-  prompt: zod.z.string().optional(),
-  model: ModelSettingsSchema.optional(),
-  tools: zod.z.array(zod.z.string()).optional(),
-  dataComponents: zod.z.array(zod.z.string()).optional(),
-  artifactComponents: zod.z.array(zod.z.string()).optional(),
-  canTransferTo: zod.z.array(zod.z.string()).optional(),
-  canDelegateTo: zod.z.array(zod.z.string()).optional(),
-  type: zod.z.enum(["internal", "external"]).optional()
-});
-var ToolApiInsertSchema2 = zod.z.object({
-  id: zod.z.string().optional(),
-  name: zod.z.string(),
-  description: zod.z.string().optional(),
-  type: zod.z.enum(["mcp", "hosted"]),
-  config: zod.z.record(zod.z.string(), zod.z.unknown()),
-  credentialReferenceId: zod.z.string().optional()
-});
-var ApiKeyApiSelectSchema2 = zod.z.object({
-  id: zod.z.string(),
-  tenantId: zod.z.string(),
-  projectId: zod.z.string(),
-  agentId: zod.z.string(),
-  publicId: zod.z.string(),
-  keyHash: zod.z.string(),
-  keyPrefix: zod.z.string(),
-  name: zod.z.string().optional(),
-  lastUsedAt: zod.z.string().optional(),
-  expiresAt: zod.z.string().optional(),
-  createdAt: zod.z.string(),
-  updatedAt: zod.z.string()
-});
-var ApiKeyApiCreationResponseSchema2 = zod.z.object({
-  data: zod.z.object({
-    apiKey: ApiKeyApiSelectSchema2,
-    key: zod.z.string()
-  })
-});
-var CredentialReferenceApiInsertSchema2 = zod.z.object({
-  id: zod.z.string(),
-  tenantId: zod.z.string().optional(),
-  projectId: zod.z.string().optional(),
-  name: zod.z.string(),
-  type: zod.z.enum(CredentialStoreType),
-  credentialStoreId: zod.z.string(),
-  retrievalParams: zod.z.record(zod.z.string(), zod.z.unknown()).nullish()
-});
-var DataComponentApiInsertSchema2 = zod.z.object({
-  id: zod.z.string(),
-  name: zod.z.string(),
-  description: zod.z.string().optional(),
-  props: zod.z.record(zod.z.string(), zod.z.unknown()),
-  render: zod.z.object({
-    component: zod.z.string(),
-    mockData: zod.z.record(zod.z.string(), zod.z.unknown())
-  }).nullable().optional()
-});
-var ArtifactComponentApiInsertSchema2 = ArtifactComponentApiInsertSchema;
-var ContextConfigApiInsertSchema2 = zod.z.object({
-  id: zod.z.string().optional(),
-  name: zod.z.string().optional(),
-  description: zod.z.string().optional(),
-  type: zod.z.string().optional(),
-  config: zod.z.record(zod.z.string(), zod.z.unknown()).optional()
-});
-var ExternalAgentApiInsertSchema2 = zod.z.object({
-  id: zod.z.string().optional(),
-  name: zod.z.string(),
-  description: zod.z.string().optional(),
-  baseUrl: zod.z.string(),
-  headers: zod.z.record(zod.z.string(), zod.z.string()).nullable().optional(),
-  credentialReferenceId: zod.z.string().nullable().optional(),
-  type: zod.z.literal("external").optional()
-});
-var AgentAgentApiInsertSchema = zod.z.object({
-  id: zod.z.string().optional(),
-  name: zod.z.string(),
-  description: zod.z.string().optional(),
-  defaultSubAgentId: zod.z.string().optional()
-});
-var FullAgentDefinitionSchema = AgentAgentApiInsertSchema.extend({
-  subAgents: zod.z.record(zod.z.string(), zod.z.union([FullAgentAgentInsertSchema])),
-  contextConfig: zod.z.optional(ContextConfigApiInsertSchema2),
-  models: zod.z.object({
-    base: zod.z.object({
-      model: zod.z.string(),
-      providerOptions: zod.z.record(zod.z.string(), zod.z.record(zod.z.string(), zod.z.unknown())).optional()
-    }).optional(),
-    structuredOutput: zod.z.object({
-      model: zod.z.string(),
-      providerOptions: zod.z.record(zod.z.string(), zod.z.record(zod.z.string(), zod.z.unknown())).optional()
-    }).optional(),
-    summarizer: zod.z.object({
-      model: zod.z.string(),
-      providerOptions: zod.z.record(zod.z.string(), zod.z.record(zod.z.string(), zod.z.unknown())).optional()
-    }).optional()
-  }).optional(),
-  stopWhen: zod.z.object({
-    transferCountIs: zod.z.number().min(AGENT_EXECUTION_TRANSFER_COUNT_MIN2).max(AGENT_EXECUTION_TRANSFER_COUNT_MAX2).optional()
-  }).optional(),
-  prompt: zod.z.string().max(VALIDATION_AGENT_PROMPT_MAX_CHARS2).optional(),
-  statusUpdates: zod.z.object({
-    enabled: zod.z.boolean().optional(),
-    numEvents: zod.z.number().min(1).max(STATUS_UPDATE_MAX_NUM_EVENTS2).optional(),
-    timeInSeconds: zod.z.number().min(1).max(STATUS_UPDATE_MAX_INTERVAL_SECONDS2).optional(),
-    prompt: zod.z.string().max(VALIDATION_SUB_AGENT_PROMPT_MAX_CHARS2).optional(),
-    statusComponents: zod.z.array(
-      zod.z.object({
-        type: zod.z.string(),
-        description: zod.z.string().optional(),
-        detailsSchema: zod.z.object({
-          type: zod.z.literal("object"),
-          properties: zod.z.record(zod.z.string(), zod.z.any()),
-          required: zod.z.array(zod.z.string()).optional()
-        }).optional()
-      })
-    ).optional()
-  }).optional()
-});
-var MIN_ID_LENGTH2 = 1;
-var MAX_ID_LENGTH2 = 255;
-var URL_SAFE_ID_PATTERN2 = /^[a-zA-Z0-9\-_.]+$/;
-var resourceIdSchema2 = zod.z.string().min(MIN_ID_LENGTH2).max(MAX_ID_LENGTH2).regex(URL_SAFE_ID_PATTERN2, {
-  message: "ID must contain only letters, numbers, hyphens, underscores, and dots"
-});
-function generateIdFromName(name) {
-  return name.toLowerCase().replace(/[^a-zA-Z0-9]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "").slice(0, MAX_ID_LENGTH2);
-}
-
-exports.ACTIVITY_NAMES = ACTIVITY_NAMES;
-exports.ACTIVITY_STATUS = ACTIVITY_STATUS;
-exports.ACTIVITY_TYPES = ACTIVITY_TYPES;
-exports.AGENT_IDS = AGENT_IDS;
-exports.AGGREGATE_OPERATORS = AGGREGATE_OPERATORS;
-exports.AI_OPERATIONS = AI_OPERATIONS;
-exports.AI_TOOL_TYPES = AI_TOOL_TYPES;
-exports.AgentAgentApiInsertSchema = AgentAgentApiInsertSchema;
-exports.AgentApiInsertSchema = AgentApiInsertSchema2;
-exports.AgentStopWhenSchema = AgentStopWhenSchema;
-exports.ApiKeyApiCreationResponseSchema = ApiKeyApiCreationResponseSchema2;
-exports.ApiKeyApiSelectSchema = ApiKeyApiSelectSchema2;
-exports.ArtifactComponentApiInsertSchema = ArtifactComponentApiInsertSchema2;
-exports.ContextConfigApiInsertSchema = ContextConfigApiInsertSchema2;
-exports.CredentialReferenceApiInsertSchema = CredentialReferenceApiInsertSchema2;
-exports.CredentialStoreType = CredentialStoreType;
-exports.DATA_SOURCES = DATA_SOURCES;
-exports.DATA_TYPES = DATA_TYPES;
-exports.DELEGATION_FROM_SUB_AGENT_ID = DELEGATION_FROM_SUB_AGENT_ID;
-exports.DELEGATION_ID = DELEGATION_ID;
-exports.DELEGATION_TO_SUB_AGENT_ID = DELEGATION_TO_SUB_AGENT_ID;
-exports.DataComponentApiInsertSchema = DataComponentApiInsertSchema2;
-exports.ErrorResponseSchema = ErrorResponseSchema2;
-exports.ExternalAgentApiInsertSchema = ExternalAgentApiInsertSchema2;
-exports.FIELD_TYPES = FIELD_TYPES;
-exports.FullAgentDefinitionSchema = FullAgentDefinitionSchema;
-exports.FunctionApiInsertSchema = FunctionApiInsertSchema;
-exports.FunctionApiSelectSchema = FunctionApiSelectSchema;
-exports.FunctionApiUpdateSchema = FunctionApiUpdateSchema;
-exports.IdParamsSchema = IdParamsSchema;
-exports.ListResponseSchema = ListResponseSchema;
-exports.MAX_ID_LENGTH = MAX_ID_LENGTH2;
-exports.MCPTransportType = MCPTransportType;
-exports.MIN_ID_LENGTH = MIN_ID_LENGTH2;
-exports.ModelSettingsSchema = ModelSettingsSchema;
-exports.OPERATORS = OPERATORS;
-exports.ORDER_DIRECTIONS = ORDER_DIRECTIONS;
-exports.PANEL_TYPES = PANEL_TYPES;
-exports.PaginationSchema = PaginationSchema2;
-exports.QUERY_DEFAULTS = QUERY_DEFAULTS;
-exports.QUERY_EXPRESSIONS = QUERY_EXPRESSIONS;
-exports.QUERY_FIELD_CONFIGS = QUERY_FIELD_CONFIGS;
-exports.QUERY_TYPES = QUERY_TYPES;
-exports.REDUCE_OPERATIONS = REDUCE_OPERATIONS;
-exports.SPAN_KEYS = SPAN_KEYS;
-exports.SPAN_NAMES = SPAN_NAMES;
-exports.SingleResponseSchema = SingleResponseSchema;
-exports.StopWhenSchema = StopWhenSchema;
-exports.SubAgentStopWhenSchema = SubAgentStopWhenSchema;
-exports.TRANSFER_FROM_SUB_AGENT_ID = TRANSFER_FROM_SUB_AGENT_ID;
-exports.TRANSFER_TO_SUB_AGENT_ID = TRANSFER_TO_SUB_AGENT_ID;
-exports.TenantParamsSchema = TenantParamsSchema2;
-exports.TenantProjectIdParamsSchema = TenantProjectIdParamsSchema2;
-exports.TenantProjectParamsSchema = TenantProjectParamsSchema2;
-exports.ToolApiInsertSchema = ToolApiInsertSchema2;
-exports.UNKNOWN_VALUE = UNKNOWN_VALUE;
-exports.URL_SAFE_ID_PATTERN = URL_SAFE_ID_PATTERN2;
-exports.detectAuthenticationRequired = detectAuthenticationRequired;
-exports.generateIdFromName = generateIdFromName;
-exports.resourceIdSchema = resourceIdSchema2;
-exports.validatePropsAsJsonSchema = validatePropsAsJsonSchema;