@inkeep/agents-core 0.35.1 → 0.35.3

package/dist/validation/index.cjs

@@ -1,2930 +0,0 @@
-'use strict';
-
-var zodOpenapi = require('@hono/zod-openapi');
-var drizzleOrm = require('drizzle-orm');
-var pgCore = require('drizzle-orm/pg-core');
-var drizzleZod = require('drizzle-zod');
-var zod = require('zod');
-var Ajv = require('ajv');
-
-function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
-
-var Ajv__default = /*#__PURE__*/_interopDefault(Ajv);
-
-// src/validation/cycleDetection.ts
-function detectDelegationCycles(agentData) {
-  const graph = buildDelegationGraph(agentData);
-  const cycles = [];
-  const visited = /* @__PURE__ */ new Set();
-  const stack = /* @__PURE__ */ new Set();
-  const path = [];
-  function dfs(node) {
-    visited.add(node);
-    stack.add(node);
-    path.push(node);
-    for (const neighbor of graph.get(node) || []) {
-      if (!visited.has(neighbor)) {
-        if (dfs(neighbor)) return true;
-      } else if (stack.has(neighbor)) {
-        const cycleStart = path.indexOf(neighbor);
-        cycles.push(
-          `Circular delegation detected: ${[...path.slice(cycleStart), neighbor].join(" \u2192 ")}`
-        );
-        return true;
-      }
-    }
-    stack.delete(node);
-    path.pop();
-    return false;
-  }
-  for (const node of graph.keys()) {
-    if (!visited.has(node)) {
-      path.length = 0;
-      dfs(node);
-    }
-  }
-  return cycles;
-}
-function buildDelegationGraph(agentData) {
-  const graph = /* @__PURE__ */ new Map();
-  for (const [subAgentId, subAgent] of Object.entries(agentData.subAgents)) {
-    const delegates = subAgent.canDelegateTo?.filter((d) => typeof d === "string");
-    if (delegates?.length) {
-      graph.set(subAgentId, delegates);
-    }
-  }
-  return graph;
-}
-
-// 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
-};
-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]
-    })
-  })
-);
-
-// 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 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");
-var FunctionToolConfigSchema = 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");
-var SubAgentApiUpdateSchema = 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");
-var SubAgentRelationApiInsertSchema = 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");
-var SubAgentRelationApiUpdateSchema = 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");
-var SubAgentRelationQuerySchema = 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
-});
-var ExternalSubAgentRelationApiInsertSchema = 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");
-var AgentApiUpdateSchema = createApiUpdateSchema(AgentUpdateSchema).openapi("AgentUpdate");
-var TaskSelectSchema = createSelectSchema(tasks);
-var TaskInsertSchema = createInsertSchema(tasks).extend({
-  id: resourceIdSchema,
-  conversationId: resourceIdSchema.optional()
-});
-var TaskUpdateSchema = TaskInsertSchema.partial();
-var TaskApiSelectSchema = createApiSchema(TaskSelectSchema);
-var TaskApiInsertSchema = createApiInsertSchema(TaskInsertSchema);
-var TaskApiUpdateSchema = createApiUpdateSchema(TaskUpdateSchema);
-var TaskRelationSelectSchema = createSelectSchema(taskRelations);
-var TaskRelationInsertSchema = createInsertSchema(taskRelations).extend({
-  id: resourceIdSchema,
-  parentTaskId: resourceIdSchema,
-  childTaskId: resourceIdSchema
-});
-var TaskRelationUpdateSchema = TaskRelationInsertSchema.partial();
-var TaskRelationApiSelectSchema = createApiSchema(TaskRelationSelectSchema);
-var TaskRelationApiInsertSchema = createApiInsertSchema(TaskRelationInsertSchema);
-var TaskRelationApiUpdateSchema = 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");
-var ConversationApiInsertSchema = createApiInsertSchema(ConversationInsertSchema).openapi("ConversationCreate");
-var ConversationApiUpdateSchema = 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");
-var MessageApiInsertSchema = createApiInsertSchema(MessageInsertSchema).openapi("MessageCreate");
-var MessageApiUpdateSchema = createApiUpdateSchema(MessageUpdateSchema).openapi("MessageUpdate");
-var ContextCacheSelectSchema = createSelectSchema(contextCache);
-var ContextCacheInsertSchema = createInsertSchema(contextCache);
-var ContextCacheUpdateSchema = ContextCacheInsertSchema.partial();
-var ContextCacheApiSelectSchema = createApiSchema(ContextCacheSelectSchema);
-var ContextCacheApiInsertSchema = createApiInsertSchema(ContextCacheInsertSchema);
-var ContextCacheApiUpdateSchema = createApiUpdateSchema(ContextCacheUpdateSchema);
-var DataComponentSelectSchema = createSelectSchema(dataComponents);
-var DataComponentInsertSchema = createInsertSchema(dataComponents).extend({
-  id: resourceIdSchema
-});
-var DataComponentBaseSchema = DataComponentInsertSchema.omit({
-  createdAt: true,
-  updatedAt: true
-});
-var DataComponentUpdateSchema = DataComponentInsertSchema.partial();
-var DataComponentApiSelectSchema = createApiSchema(DataComponentSelectSchema).openapi("DataComponent");
-var DataComponentApiInsertSchema = createApiInsertSchema(DataComponentInsertSchema).openapi("DataComponentCreate");
-var DataComponentApiUpdateSchema = createApiUpdateSchema(DataComponentUpdateSchema).openapi("DataComponentUpdate");
-var SubAgentDataComponentSelectSchema = createSelectSchema(subAgentDataComponents);
-var SubAgentDataComponentInsertSchema = createInsertSchema(subAgentDataComponents);
-var SubAgentDataComponentUpdateSchema = SubAgentDataComponentInsertSchema.partial();
-var SubAgentDataComponentApiSelectSchema = createAgentScopedApiSchema(
-  SubAgentDataComponentSelectSchema
-);
-var SubAgentDataComponentApiInsertSchema = SubAgentDataComponentInsertSchema.omit({
-  tenantId: true,
-  projectId: true,
-  id: true,
-  createdAt: true
-});
-var SubAgentDataComponentApiUpdateSchema = 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");
-var ArtifactComponentApiUpdateSchema = 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
-);
-var SubAgentArtifactComponentApiInsertSchema = SubAgentArtifactComponentInsertSchema.omit({
-  tenantId: true,
-  projectId: true,
-  id: true,
-  createdAt: true
-});
-var SubAgentArtifactComponentApiUpdateSchema = 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");
-var ExternalAgentApiUpdateSchema = createApiUpdateSchema(ExternalAgentUpdateSchema).openapi("ExternalAgentUpdate");
-var AllAgentSchema = 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");
-var ApiKeyApiCreationResponseSchema = zodOpenapi.z.object({
-  data: zodOpenapi.z.object({
-    apiKey: ApiKeyApiSelectSchema,
-    key: zodOpenapi.z.string().describe("The full API key (shown only once)")
-  })
-});
-var ApiKeyApiInsertSchema = 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");
-var ApiKeyApiUpdateSchema = 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");
-var CredentialReferenceApiUpdateSchema = 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");
-var CredentialStoreListResponseSchema = zodOpenapi.z.object({
-  data: zodOpenapi.z.array(CredentialStoreSchema).describe("List of credential stores")
-}).openapi("CredentialStoreListResponse");
-var CreateCredentialInStoreRequestSchema = 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");
-var CreateCredentialInStoreResponseSchema = 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");
-var OAuthLoginQuerySchema = 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");
-var OAuthCallbackQuerySchema = 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");
-var MCPToolConfigSchema = 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");
-var ToolApiUpdateSchema = 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");
-var FunctionToolApiUpdateSchema = 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");
-var FetchDefinitionSchema = 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");
-var ContextConfigApiUpdateSchema = 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");
-var SubAgentToolRelationApiInsertSchema = createAgentScopedApiInsertSchema(
-  SubAgentToolRelationInsertSchema
-).openapi("SubAgentToolRelationCreate");
-var SubAgentToolRelationApiUpdateSchema = 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");
-var SubAgentExternalAgentRelationApiInsertSchema = createAgentScopedApiInsertSchema(
-  SubAgentExternalAgentRelationInsertSchema
-).omit({ id: true, subAgentId: true }).openapi("SubAgentExternalAgentRelationCreate");
-var SubAgentExternalAgentRelationApiUpdateSchema = 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");
-var SubAgentTeamAgentRelationApiInsertSchema = createAgentScopedApiInsertSchema(
-  SubAgentTeamAgentRelationInsertSchema
-).omit({ id: true, subAgentId: true }).openapi("SubAgentTeamAgentRelationCreate");
-var SubAgentTeamAgentRelationApiUpdateSchema = createAgentScopedApiUpdateSchema(
-  SubAgentTeamAgentRelationUpdateSchema
-).openapi("SubAgentTeamAgentRelationUpdate");
-var LedgerArtifactSelectSchema = createSelectSchema(ledgerArtifacts);
-var LedgerArtifactInsertSchema = createInsertSchema(ledgerArtifacts);
-var LedgerArtifactUpdateSchema = LedgerArtifactInsertSchema.partial();
-var LedgerArtifactApiSelectSchema = createApiSchema(LedgerArtifactSelectSchema);
-var LedgerArtifactApiInsertSchema = createApiInsertSchema(LedgerArtifactInsertSchema);
-var LedgerArtifactApiUpdateSchema = 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");
-var ListResponseSchema = (itemSchema) => zodOpenapi.z.object({
-  data: zodOpenapi.z.array(itemSchema),
-  pagination: PaginationSchema
-});
-var SingleResponseSchema = (itemSchema) => zodOpenapi.z.object({
-  data: itemSchema
-});
-var ErrorResponseSchema = zodOpenapi.z.object({
-  error: zodOpenapi.z.string(),
-  message: zodOpenapi.z.string().optional(),
-  details: zodOpenapi.z.any().optional().openapi({
-    description: "Additional error details"
-  })
-}).openapi("ErrorResponse");
-var ExistsResponseSchema = zodOpenapi.z.object({
-  exists: zodOpenapi.z.boolean()
-}).openapi("ExistsResponse");
-var RemovedResponseSchema = 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"
-);
-var ProjectApiUpdateSchema = 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");
-var ProjectResponse = zodOpenapi.z.object({ data: ProjectApiSelectSchema }).openapi("ProjectResponse");
-var SubAgentResponse = zodOpenapi.z.object({ data: SubAgentApiSelectSchema }).openapi("SubAgentResponse");
-var AgentResponse = zodOpenapi.z.object({ data: AgentApiSelectSchema }).openapi("AgentResponse");
-var ToolResponse = zodOpenapi.z.object({ data: ToolApiSelectSchema }).openapi("ToolResponse");
-var ExternalAgentResponse = zodOpenapi.z.object({ data: ExternalAgentApiSelectSchema }).openapi("ExternalAgentResponse");
-var ContextConfigResponse = zodOpenapi.z.object({ data: ContextConfigApiSelectSchema }).openapi("ContextConfigResponse");
-var ApiKeyResponse = zodOpenapi.z.object({ data: ApiKeyApiSelectSchema }).openapi("ApiKeyResponse");
-var CredentialReferenceResponse = zodOpenapi.z.object({ data: CredentialReferenceApiSelectSchema }).openapi("CredentialReferenceResponse");
-var FunctionResponse = zodOpenapi.z.object({ data: FunctionApiSelectSchema }).openapi("FunctionResponse");
-var FunctionToolResponse = zodOpenapi.z.object({ data: FunctionToolApiSelectSchema }).openapi("FunctionToolResponse");
-var DataComponentResponse = zodOpenapi.z.object({ data: DataComponentApiSelectSchema }).openapi("DataComponentResponse");
-var ArtifactComponentResponse = zodOpenapi.z.object({ data: ArtifactComponentApiSelectSchema }).openapi("ArtifactComponentResponse");
-var SubAgentRelationResponse = zodOpenapi.z.object({ data: SubAgentRelationApiSelectSchema }).openapi("SubAgentRelationResponse");
-var SubAgentToolRelationResponse = zodOpenapi.z.object({ data: SubAgentToolRelationApiSelectSchema }).openapi("SubAgentToolRelationResponse");
-var ConversationResponse = zodOpenapi.z.object({ data: ConversationApiSelectSchema }).openapi("ConversationResponse");
-var MessageResponse = zodOpenapi.z.object({ data: MessageApiSelectSchema }).openapi("MessageResponse");
-var ProjectListResponse = zodOpenapi.z.object({
-  data: zodOpenapi.z.array(ProjectApiSelectSchema),
-  pagination: PaginationSchema
-}).openapi("ProjectListResponse");
-var SubAgentListResponse = zodOpenapi.z.object({
-  data: zodOpenapi.z.array(SubAgentApiSelectSchema),
-  pagination: PaginationSchema
-}).openapi("SubAgentListResponse");
-var AgentListResponse = zodOpenapi.z.object({
-  data: zodOpenapi.z.array(AgentApiSelectSchema),
-  pagination: PaginationSchema
-}).openapi("AgentListResponse");
-var ToolListResponse = zodOpenapi.z.object({
-  data: zodOpenapi.z.array(ToolApiSelectSchema),
-  pagination: PaginationSchema
-}).openapi("ToolListResponse");
-var ExternalAgentListResponse = zodOpenapi.z.object({
-  data: zodOpenapi.z.array(ExternalAgentApiSelectSchema),
-  pagination: PaginationSchema
-}).openapi("ExternalAgentListResponse");
-var ContextConfigListResponse = zodOpenapi.z.object({
-  data: zodOpenapi.z.array(ContextConfigApiSelectSchema),
-  pagination: PaginationSchema
-}).openapi("ContextConfigListResponse");
-var ApiKeyListResponse = zodOpenapi.z.object({
-  data: zodOpenapi.z.array(ApiKeyApiSelectSchema),
-  pagination: PaginationSchema
-}).openapi("ApiKeyListResponse");
-var CredentialReferenceListResponse = zodOpenapi.z.object({
-  data: zodOpenapi.z.array(CredentialReferenceApiSelectSchema),
-  pagination: PaginationSchema
-}).openapi("CredentialReferenceListResponse");
-var FunctionListResponse = zodOpenapi.z.object({
-  data: zodOpenapi.z.array(FunctionApiSelectSchema),
-  pagination: PaginationSchema
-}).openapi("FunctionListResponse");
-var FunctionToolListResponse = zodOpenapi.z.object({
-  data: zodOpenapi.z.array(FunctionToolApiSelectSchema),
-  pagination: PaginationSchema
-}).openapi("FunctionToolListResponse");
-var DataComponentListResponse = zodOpenapi.z.object({
-  data: zodOpenapi.z.array(DataComponentApiSelectSchema),
-  pagination: PaginationSchema
-}).openapi("DataComponentListResponse");
-var ArtifactComponentListResponse = zodOpenapi.z.object({
-  data: zodOpenapi.z.array(ArtifactComponentApiSelectSchema),
-  pagination: PaginationSchema
-}).openapi("ArtifactComponentListResponse");
-var SubAgentRelationListResponse = zodOpenapi.z.object({
-  data: zodOpenapi.z.array(SubAgentRelationApiSelectSchema),
-  pagination: PaginationSchema
-}).openapi("SubAgentRelationListResponse");
-var SubAgentToolRelationListResponse = zodOpenapi.z.object({
-  data: zodOpenapi.z.array(SubAgentToolRelationApiSelectSchema),
-  pagination: PaginationSchema
-}).openapi("SubAgentToolRelationListResponse");
-var ConversationListResponse = zodOpenapi.z.object({
-  data: zodOpenapi.z.array(ConversationApiSelectSchema),
-  pagination: PaginationSchema
-}).openapi("ConversationListResponse");
-var MessageListResponse = zodOpenapi.z.object({
-  data: zodOpenapi.z.array(MessageApiSelectSchema),
-  pagination: PaginationSchema
-}).openapi("MessageListResponse");
-var SubAgentDataComponentResponse = zodOpenapi.z.object({ data: SubAgentDataComponentApiSelectSchema }).openapi("SubAgentDataComponentResponse");
-var SubAgentArtifactComponentResponse = zodOpenapi.z.object({ data: SubAgentArtifactComponentApiSelectSchema }).openapi("SubAgentArtifactComponentResponse");
-var SubAgentDataComponentListResponse = zodOpenapi.z.object({
-  data: zodOpenapi.z.array(SubAgentDataComponentApiSelectSchema),
-  pagination: PaginationSchema
-}).openapi("SubAgentDataComponentListResponse");
-var SubAgentArtifactComponentListResponse = zodOpenapi.z.object({
-  data: zodOpenapi.z.array(SubAgentArtifactComponentApiSelectSchema),
-  pagination: PaginationSchema
-}).openapi("SubAgentArtifactComponentListResponse");
-var FullProjectDefinitionResponse = zodOpenapi.z.object({ data: FullProjectDefinitionSchema }).openapi("FullProjectDefinitionResponse");
-var AgentWithinContextOfProjectResponse = zodOpenapi.z.object({ data: AgentWithinContextOfProjectSchema }).openapi("AgentWithinContextOfProjectResponse");
-var RelatedAgentInfoListResponse = zodOpenapi.z.object({
-  data: zodOpenapi.z.array(RelatedAgentInfoSchema),
-  pagination: PaginationSchema
-}).openapi("RelatedAgentInfoListResponse");
-var ComponentAssociationListResponse = zodOpenapi.z.object({ data: zodOpenapi.z.array(ComponentAssociationSchema) }).openapi("ComponentAssociationListResponse");
-var McpToolResponse = zodOpenapi.z.object({ data: McpToolSchema }).openapi("McpToolResponse");
-var McpToolListResponse = zodOpenapi.z.object({
-  data: zodOpenapi.z.array(McpToolSchema),
-  pagination: PaginationSchema
-}).openapi("McpToolListResponse");
-var SubAgentTeamAgentRelationResponse = zodOpenapi.z.object({ data: SubAgentTeamAgentRelationApiSelectSchema }).openapi("SubAgentTeamAgentRelationResponse");
-var SubAgentTeamAgentRelationListResponse = zodOpenapi.z.object({
-  data: zodOpenapi.z.array(SubAgentTeamAgentRelationApiSelectSchema),
-  pagination: PaginationSchema
-}).openapi("SubAgentTeamAgentRelationListResponse");
-var SubAgentExternalAgentRelationResponse = zodOpenapi.z.object({ data: SubAgentExternalAgentRelationApiSelectSchema }).openapi("SubAgentExternalAgentRelationResponse");
-var SubAgentExternalAgentRelationListResponse = zodOpenapi.z.object({
-  data: zodOpenapi.z.array(SubAgentExternalAgentRelationApiSelectSchema),
-  pagination: PaginationSchema
-}).openapi("SubAgentExternalAgentRelationListResponse");
-var DataComponentArrayResponse = zodOpenapi.z.object({ data: zodOpenapi.z.array(DataComponentApiSelectSchema) }).openapi("DataComponentArrayResponse");
-var ArtifactComponentArrayResponse = zodOpenapi.z.object({ data: zodOpenapi.z.array(ArtifactComponentApiSelectSchema) }).openapi("ArtifactComponentArrayResponse");
-var HeadersScopeSchema = 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
-});
-var TenantIdParamsSchema = TenantParamsSchema.extend({
-  id: resourceIdSchema
-});
-var TenantProjectParamsSchema = TenantParamsSchema.extend({
-  projectId: ProjectId
-});
-var TenantProjectIdParamsSchema = TenantProjectParamsSchema.extend({
-  id: resourceIdSchema
-});
-var TenantProjectAgentParamsSchema = TenantProjectParamsSchema.extend({
-  agentId: AgentId
-});
-var TenantProjectAgentIdParamsSchema = TenantProjectAgentParamsSchema.extend({
-  id: resourceIdSchema
-});
-var TenantProjectAgentSubAgentParamsSchema = TenantProjectAgentParamsSchema.extend({
-  subAgentId: SubAgentId
-});
-var TenantProjectAgentSubAgentIdParamsSchema = TenantProjectAgentSubAgentParamsSchema.extend({
-  id: resourceIdSchema
-});
-var PaginationQueryParamsSchema = zodOpenapi.z.object({
-  page: pageNumber,
-  limit: limitNumber
-}).openapi("PaginationQueryParams");
-
-// src/validation/agentFull.ts
-function validateAndTypeAgentData(data) {
-  return AgentWithinContextOfProjectSchema.parse(data);
-}
-function validateToolReferences(agentData, availableToolIds) {
-  if (!availableToolIds) {
-    return;
-  }
-  const errors = [];
-  for (const [subAgentId, subAgent] of Object.entries(agentData.subAgents)) {
-    if (subAgent.canUse && Array.isArray(subAgent.canUse)) {
-      for (const canUseItem of subAgent.canUse) {
-        if (!availableToolIds.has(canUseItem.toolId)) {
-          errors.push(`Agent '${subAgentId}' references non-existent tool '${canUseItem.toolId}'`);
-        }
-      }
-    }
-  }
-  if (errors.length > 0) {
-    throw new Error(`Tool reference validation failed:
-${errors.join("\n")}`);
-  }
-}
-function validateDataComponentReferences(agentData, availableDataComponentIds) {
-  if (!availableDataComponentIds) {
-    return;
-  }
-  const errors = [];
-  for (const [subAgentId, subAgent] of Object.entries(agentData.subAgents)) {
-    if (subAgent.dataComponents) {
-      for (const dataComponentId of subAgent.dataComponents) {
-        if (!availableDataComponentIds.has(dataComponentId)) {
-          errors.push(
-            `Agent '${subAgentId}' references non-existent dataComponent '${dataComponentId}'`
-          );
-        }
-      }
-    }
-  }
-  if (errors.length > 0) {
-    throw new Error(`DataComponent reference validation failed:
-${errors.join("\n")}`);
-  }
-}
-function validateArtifactComponentReferences(agentData, availableArtifactComponentIds) {
-  if (!availableArtifactComponentIds) {
-    return;
-  }
-  const errors = [];
-  for (const [subAgentId, subAgent] of Object.entries(agentData.subAgents)) {
-    if (subAgent.artifactComponents) {
-      for (const artifactComponentId of subAgent.artifactComponents) {
-        if (!availableArtifactComponentIds.has(artifactComponentId)) {
-          errors.push(
-            `Agent '${subAgentId}' references non-existent artifactComponent '${artifactComponentId}'`
-          );
-        }
-      }
-    }
-  }
-  if (errors.length > 0) {
-    throw new Error(`ArtifactComponent reference validation failed:
-${errors.join("\n")}`);
-  }
-}
-function validateAgentRelationships(agentData) {
-  const errors = [];
-  const availableAgentIds = new Set(Object.keys(agentData.subAgents));
-  const availableExternalAgentIds = new Set(Object.keys(agentData.externalAgents ?? {}));
-  for (const [subAgentId, subAgent] of Object.entries(agentData.subAgents)) {
-    if (subAgent.canTransferTo && Array.isArray(subAgent.canTransferTo)) {
-      for (const targetId of subAgent.canTransferTo) {
-        if (!availableAgentIds.has(targetId)) {
-          errors.push(
-            `Agent '${subAgentId}' has transfer target '${targetId}' that doesn't exist in agent`
-          );
-        }
-      }
-    }
-    if (subAgent.canDelegateTo && Array.isArray(subAgent.canDelegateTo)) {
-      for (const targetItem of subAgent.canDelegateTo) {
-        console.log("targetItem", targetItem);
-        if (typeof targetItem === "string") {
-          console.log("targetItem is string", targetItem);
-          if (!availableAgentIds.has(targetItem) && !availableExternalAgentIds.has(targetItem)) {
-            errors.push(
-              `Agent '${subAgentId}' has delegation target '${targetItem}' that doesn't exist in agent`
-            );
-          }
-        }
-      }
-    }
-  }
-  const cycles = detectDelegationCycles(agentData);
-  if (cycles.length > 0) {
-    errors.push(...cycles);
-  }
-  if (errors.length > 0)
-    throw new Error(`Agent relationship validation failed:
-${errors.join("\n")}`);
-}
-function validateSubAgentExternalAgentRelations(agentData, availableExternalAgentIds) {
-  if (!availableExternalAgentIds) {
-    return;
-  }
-  const errors = [];
-  for (const [subAgentId, subAgent] of Object.entries(agentData.subAgents)) {
-    if (subAgent.canDelegateTo && Array.isArray(subAgent.canDelegateTo)) {
-      for (const targetItem of subAgent.canDelegateTo) {
-        if (typeof targetItem === "object" && "externalAgentId" in targetItem) {
-          if (!availableExternalAgentIds.has(targetItem.externalAgentId)) {
-            errors.push(
-              `Agent '${subAgentId}' has delegation target '${targetItem.externalAgentId}' that doesn't exist in agent`
-            );
-          }
-        }
-      }
-    }
-  }
-  if (errors.length > 0)
-    throw new Error(`Sub agent external agent relation validation failed:
-${errors.join("\n")}`);
-}
-function validateAgentStructure(agentData, projectResources) {
-  if (agentData.defaultSubAgentId && !agentData.subAgents[agentData.defaultSubAgentId]) {
-    throw new Error(`Default agent '${agentData.defaultSubAgentId}' does not exist in agents`);
-  }
-  if (projectResources) {
-    validateToolReferences(agentData, projectResources.toolIds);
-    validateDataComponentReferences(agentData, projectResources.dataComponentIds);
-    validateArtifactComponentReferences(agentData, projectResources.artifactComponentIds);
-    validateSubAgentExternalAgentRelations(agentData, projectResources.externalAgentIds);
-  }
-  validateAgentRelationships(agentData);
-}
-var TransferDataSchema = zod.z.object({
-  fromSubAgent: zod.z.string().describe("ID of the sub-agent transferring control"),
-  targetSubAgent: zod.z.string().describe("ID of the sub-agent receiving control"),
-  reason: zod.z.string().optional().describe("Reason for the transfer"),
-  context: zod.z.any().optional().describe("Additional context data")
-});
-var DelegationSentDataSchema = zod.z.object({
-  delegationId: zod.z.string().describe("Unique identifier for this delegation"),
-  fromSubAgent: zod.z.string().describe("ID of the delegating sub-agent"),
-  targetSubAgent: zod.z.string().describe("ID of the sub-agent receiving the delegation"),
-  taskDescription: zod.z.string().describe("Description of the delegated task"),
-  context: zod.z.any().optional().describe("Additional context data")
-});
-var DelegationReturnedDataSchema = zod.z.object({
-  delegationId: zod.z.string().describe("Unique identifier matching the original delegation"),
-  fromSubAgent: zod.z.string().describe("ID of the sub-agent that completed the task"),
-  targetSubAgent: zod.z.string().describe("ID of the sub-agent receiving the result"),
-  result: zod.z.any().optional().describe("Result data from the delegated task")
-});
-var DataOperationDetailsSchema = zod.z.object({
-  timestamp: zod.z.number().describe("Unix timestamp in milliseconds"),
-  subAgentId: zod.z.string().describe("ID of the sub-agent that generated this data"),
-  data: zod.z.any().describe("The actual data payload")
-});
-var DataOperationEventSchema = zod.z.object({
-  type: zod.z.string().describe("Event type identifier"),
-  label: zod.z.string().describe("Human-readable label for the event"),
-  details: DataOperationDetailsSchema
-});
-var A2AMessageMetadataSchema = zod.z.object({
-  fromSubAgentId: zod.z.string().optional().describe("ID of the sending sub-agent"),
-  toSubAgentId: zod.z.string().optional().describe("ID of the receiving sub-agent"),
-  fromExternalAgentId: zod.z.string().optional().describe("ID of the sending external agent"),
-  toExternalAgentId: zod.z.string().optional().describe("ID of the receiving external agent"),
-  taskId: zod.z.string().optional().describe("Associated task ID"),
-  a2aTaskId: zod.z.string().optional().describe("A2A-specific task ID")
-});
-
-// src/validation/id-validation.ts
-function isValidResourceId(id) {
-  const result = resourceIdSchema.safeParse(id);
-  return result.success;
-}
-function generateIdFromName(name) {
-  const id = name.toLowerCase().replace(/[^a-z0-9_-]+/g, "-").replace(/^-+|-+$/g, "").replace(/-{2,}/g, "-");
-  if (!id) {
-    throw new Error("Cannot generate valid ID from provided name");
-  }
-  const truncatedId = id.substring(0, MAX_ID_LENGTH);
-  const result = resourceIdSchema.safeParse(truncatedId);
-  if (!result.success) {
-    throw new Error(`Generated ID "${truncatedId}" is not valid: ${result.error.message}`);
-  }
-  return truncatedId;
-}
-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/validation/render-validation.ts
-var MAX_CODE_SIZE = 5e4;
-var MAX_DATA_SIZE = 1e4;
-var DANGEROUS_PATTERNS = [
-  {
-    pattern: /\beval\s*\(/i,
-    message: "eval() is not allowed"
-  },
-  {
-    pattern: /\bFunction\s*\(/i,
-    message: "Function constructor is not allowed"
-  },
-  {
-    pattern: /dangerouslySetInnerHTML/i,
-    message: "dangerouslySetInnerHTML is not allowed"
-  },
-  {
-    pattern: /<script\b/i,
-    message: "Script tags are not allowed"
-  },
-  {
-    pattern: /\bon\w+\s*=/i,
-    message: "Inline event handlers (onClick=, onLoad=, etc.) are not allowed"
-  },
-  {
-    pattern: /document\.write/i,
-    message: "document.write is not allowed"
-  },
-  {
-    pattern: /window\.location/i,
-    message: "window.location is not allowed"
-  },
-  {
-    pattern: /\.innerHTML\s*=/i,
-    message: "innerHTML manipulation is not allowed"
-  }
-];
-var ALLOWED_IMPORTS = ["lucide-react", "react"];
-function validateRender(render) {
-  const errors = [];
-  if (!render.component || typeof render.component !== "string") {
-    return {
-      isValid: false,
-      errors: [{ field: "render.component", message: "Component must be a non-empty string" }]
-    };
-  }
-  if (!render.mockData || typeof render.mockData !== "object") {
-    return {
-      isValid: false,
-      errors: [{ field: "render.mockData", message: "MockData must be an object" }]
-    };
-  }
-  if (render.component.length > MAX_CODE_SIZE) {
-    errors.push({
-      field: "render.component",
-      message: `Component size exceeds maximum allowed (${MAX_CODE_SIZE} characters)`
-    });
-  }
-  const dataString = JSON.stringify(render.mockData);
-  if (dataString.length > MAX_DATA_SIZE) {
-    errors.push({
-      field: "render.mockData",
-      message: `MockData size exceeds maximum allowed (${MAX_DATA_SIZE} characters)`
-    });
-  }
-  for (const { pattern, message } of DANGEROUS_PATTERNS) {
-    if (pattern.test(render.component)) {
-      errors.push({
-        field: "render.component",
-        message: `Component contains potentially dangerous pattern: ${message}`
-      });
-    }
-  }
-  const importMatches = render.component.matchAll(/import\s+.*?\s+from\s+['"]([^'"]+)['"]/g);
-  for (const match of importMatches) {
-    const importPath = match[1];
-    if (!ALLOWED_IMPORTS.includes(importPath) && !importPath.startsWith(".")) {
-      errors.push({
-        field: "render.component",
-        message: `Import from "${importPath}" is not allowed. Only imports from ${ALLOWED_IMPORTS.join(", ")} are permitted`
-      });
-    }
-  }
-  const hasFunctionDeclaration = /function\s+\w+\s*\(/.test(render.component);
-  if (!hasFunctionDeclaration) {
-    errors.push({
-      field: "render.component",
-      message: "Component must contain a function declaration"
-    });
-  }
-  const hasReturn = /return\s*\(?\s*</.test(render.component);
-  if (!hasReturn) {
-    errors.push({
-      field: "render.component",
-      message: "Component function must have a return statement with JSX"
-    });
-  }
-  return {
-    isValid: errors.length === 0,
-    errors
-  };
-}
-var TextStartEventSchema = zod.z.object({
-  type: zod.z.literal("text-start"),
-  id: zod.z.string()
-});
-var TextDeltaEventSchema = zod.z.object({
-  type: zod.z.literal("text-delta"),
-  id: zod.z.string(),
-  delta: zod.z.string()
-});
-var TextEndEventSchema = zod.z.object({
-  type: zod.z.literal("text-end"),
-  id: zod.z.string()
-});
-var DataComponentStreamEventSchema = zod.z.object({
-  type: zod.z.literal("data-component"),
-  id: zod.z.string(),
-  data: zod.z.any()
-});
-var DataOperationStreamEventSchema = zod.z.object({
-  type: zod.z.literal("data-operation"),
-  data: zod.z.any()
-  // Contains OperationEvent types (AgentInitializingEvent, CompletionEvent, etc.)
-});
-var DataSummaryStreamEventSchema = zod.z.object({
-  type: zod.z.literal("data-summary"),
-  data: zod.z.any()
-  // Contains SummaryEvent from entities.ts
-});
-var StreamErrorEventSchema = zod.z.object({
-  type: zod.z.literal("error"),
-  error: zod.z.string()
-});
-var StreamFinishEventSchema = zod.z.object({
-  type: zod.z.literal("finish"),
-  finishReason: zod.z.string().optional(),
-  usage: zod.z.object({
-    promptTokens: zod.z.number().optional(),
-    completionTokens: zod.z.number().optional(),
-    totalTokens: zod.z.number().optional()
-  }).optional()
-});
-var StreamEventSchema = zod.z.discriminatedUnion("type", [
-  TextStartEventSchema,
-  TextDeltaEventSchema,
-  TextEndEventSchema,
-  DataComponentStreamEventSchema,
-  DataOperationStreamEventSchema,
-  DataSummaryStreamEventSchema,
-  StreamErrorEventSchema,
-  StreamFinishEventSchema
-]);
-
-exports.A2AMessageMetadataSchema = A2AMessageMetadataSchema;
-exports.AgentApiInsertSchema = AgentApiInsertSchema;
-exports.AgentApiSelectSchema = AgentApiSelectSchema;
-exports.AgentApiUpdateSchema = AgentApiUpdateSchema;
-exports.AgentInsertSchema = AgentInsertSchema;
-exports.AgentListResponse = AgentListResponse;
-exports.AgentResponse = AgentResponse;
-exports.AgentSelectSchema = AgentSelectSchema;
-exports.AgentStopWhenSchema = AgentStopWhenSchema;
-exports.AgentUpdateSchema = AgentUpdateSchema;
-exports.AgentWithinContextOfProjectResponse = AgentWithinContextOfProjectResponse;
-exports.AgentWithinContextOfProjectSchema = AgentWithinContextOfProjectSchema;
-exports.AllAgentSchema = AllAgentSchema;
-exports.ApiKeyApiCreationResponseSchema = ApiKeyApiCreationResponseSchema;
-exports.ApiKeyApiInsertSchema = ApiKeyApiInsertSchema;
-exports.ApiKeyApiSelectSchema = ApiKeyApiSelectSchema;
-exports.ApiKeyApiUpdateSchema = ApiKeyApiUpdateSchema;
-exports.ApiKeyInsertSchema = ApiKeyInsertSchema;
-exports.ApiKeyListResponse = ApiKeyListResponse;
-exports.ApiKeyResponse = ApiKeyResponse;
-exports.ApiKeySelectSchema = ApiKeySelectSchema;
-exports.ApiKeyUpdateSchema = ApiKeyUpdateSchema;
-exports.ArtifactComponentApiInsertSchema = ArtifactComponentApiInsertSchema;
-exports.ArtifactComponentApiSelectSchema = ArtifactComponentApiSelectSchema;
-exports.ArtifactComponentApiUpdateSchema = ArtifactComponentApiUpdateSchema;
-exports.ArtifactComponentArrayResponse = ArtifactComponentArrayResponse;
-exports.ArtifactComponentInsertSchema = ArtifactComponentInsertSchema;
-exports.ArtifactComponentListResponse = ArtifactComponentListResponse;
-exports.ArtifactComponentResponse = ArtifactComponentResponse;
-exports.ArtifactComponentSelectSchema = ArtifactComponentSelectSchema;
-exports.ArtifactComponentUpdateSchema = ArtifactComponentUpdateSchema;
-exports.CanUseItemSchema = CanUseItemSchema;
-exports.ComponentAssociationListResponse = ComponentAssociationListResponse;
-exports.ComponentAssociationSchema = ComponentAssociationSchema;
-exports.ContextCacheApiInsertSchema = ContextCacheApiInsertSchema;
-exports.ContextCacheApiSelectSchema = ContextCacheApiSelectSchema;
-exports.ContextCacheApiUpdateSchema = ContextCacheApiUpdateSchema;
-exports.ContextCacheInsertSchema = ContextCacheInsertSchema;
-exports.ContextCacheSelectSchema = ContextCacheSelectSchema;
-exports.ContextCacheUpdateSchema = ContextCacheUpdateSchema;
-exports.ContextConfigApiInsertSchema = ContextConfigApiInsertSchema;
-exports.ContextConfigApiSelectSchema = ContextConfigApiSelectSchema;
-exports.ContextConfigApiUpdateSchema = ContextConfigApiUpdateSchema;
-exports.ContextConfigInsertSchema = ContextConfigInsertSchema;
-exports.ContextConfigListResponse = ContextConfigListResponse;
-exports.ContextConfigResponse = ContextConfigResponse;
-exports.ContextConfigSelectSchema = ContextConfigSelectSchema;
-exports.ContextConfigUpdateSchema = ContextConfigUpdateSchema;
-exports.ConversationApiInsertSchema = ConversationApiInsertSchema;
-exports.ConversationApiSelectSchema = ConversationApiSelectSchema;
-exports.ConversationApiUpdateSchema = ConversationApiUpdateSchema;
-exports.ConversationInsertSchema = ConversationInsertSchema;
-exports.ConversationListResponse = ConversationListResponse;
-exports.ConversationResponse = ConversationResponse;
-exports.ConversationSelectSchema = ConversationSelectSchema;
-exports.ConversationUpdateSchema = ConversationUpdateSchema;
-exports.CreateCredentialInStoreRequestSchema = CreateCredentialInStoreRequestSchema;
-exports.CreateCredentialInStoreResponseSchema = CreateCredentialInStoreResponseSchema;
-exports.CredentialReferenceApiInsertSchema = CredentialReferenceApiInsertSchema;
-exports.CredentialReferenceApiSelectSchema = CredentialReferenceApiSelectSchema;
-exports.CredentialReferenceApiUpdateSchema = CredentialReferenceApiUpdateSchema;
-exports.CredentialReferenceInsertSchema = CredentialReferenceInsertSchema;
-exports.CredentialReferenceListResponse = CredentialReferenceListResponse;
-exports.CredentialReferenceResponse = CredentialReferenceResponse;
-exports.CredentialReferenceSelectSchema = CredentialReferenceSelectSchema;
-exports.CredentialReferenceUpdateSchema = CredentialReferenceUpdateSchema;
-exports.CredentialStoreListResponseSchema = CredentialStoreListResponseSchema;
-exports.CredentialStoreSchema = CredentialStoreSchema;
-exports.DataComponentApiInsertSchema = DataComponentApiInsertSchema;
-exports.DataComponentApiSelectSchema = DataComponentApiSelectSchema;
-exports.DataComponentApiUpdateSchema = DataComponentApiUpdateSchema;
-exports.DataComponentArrayResponse = DataComponentArrayResponse;
-exports.DataComponentBaseSchema = DataComponentBaseSchema;
-exports.DataComponentInsertSchema = DataComponentInsertSchema;
-exports.DataComponentListResponse = DataComponentListResponse;
-exports.DataComponentResponse = DataComponentResponse;
-exports.DataComponentSelectSchema = DataComponentSelectSchema;
-exports.DataComponentStreamEventSchema = DataComponentStreamEventSchema;
-exports.DataComponentUpdateSchema = DataComponentUpdateSchema;
-exports.DataOperationDetailsSchema = DataOperationDetailsSchema;
-exports.DataOperationEventSchema = DataOperationEventSchema;
-exports.DataOperationStreamEventSchema = DataOperationStreamEventSchema;
-exports.DataSummaryStreamEventSchema = DataSummaryStreamEventSchema;
-exports.DelegationReturnedDataSchema = DelegationReturnedDataSchema;
-exports.DelegationSentDataSchema = DelegationSentDataSchema;
-exports.ErrorResponseSchema = ErrorResponseSchema;
-exports.ExistsResponseSchema = ExistsResponseSchema;
-exports.ExternalAgentApiInsertSchema = ExternalAgentApiInsertSchema;
-exports.ExternalAgentApiSelectSchema = ExternalAgentApiSelectSchema;
-exports.ExternalAgentApiUpdateSchema = ExternalAgentApiUpdateSchema;
-exports.ExternalAgentInsertSchema = ExternalAgentInsertSchema;
-exports.ExternalAgentListResponse = ExternalAgentListResponse;
-exports.ExternalAgentResponse = ExternalAgentResponse;
-exports.ExternalAgentSelectSchema = ExternalAgentSelectSchema;
-exports.ExternalAgentUpdateSchema = ExternalAgentUpdateSchema;
-exports.ExternalSubAgentRelationApiInsertSchema = ExternalSubAgentRelationApiInsertSchema;
-exports.ExternalSubAgentRelationInsertSchema = ExternalSubAgentRelationInsertSchema;
-exports.FetchConfigSchema = FetchConfigSchema;
-exports.FetchDefinitionSchema = FetchDefinitionSchema;
-exports.FullAgentAgentInsertSchema = FullAgentAgentInsertSchema;
-exports.FullProjectDefinitionResponse = FullProjectDefinitionResponse;
-exports.FullProjectDefinitionSchema = FullProjectDefinitionSchema;
-exports.FunctionApiInsertSchema = FunctionApiInsertSchema;
-exports.FunctionApiSelectSchema = FunctionApiSelectSchema;
-exports.FunctionApiUpdateSchema = FunctionApiUpdateSchema;
-exports.FunctionInsertSchema = FunctionInsertSchema;
-exports.FunctionListResponse = FunctionListResponse;
-exports.FunctionResponse = FunctionResponse;
-exports.FunctionSelectSchema = FunctionSelectSchema;
-exports.FunctionToolApiInsertSchema = FunctionToolApiInsertSchema;
-exports.FunctionToolApiSelectSchema = FunctionToolApiSelectSchema;
-exports.FunctionToolApiUpdateSchema = FunctionToolApiUpdateSchema;
-exports.FunctionToolConfigSchema = FunctionToolConfigSchema;
-exports.FunctionToolInsertSchema = FunctionToolInsertSchema;
-exports.FunctionToolListResponse = FunctionToolListResponse;
-exports.FunctionToolResponse = FunctionToolResponse;
-exports.FunctionToolSelectSchema = FunctionToolSelectSchema;
-exports.FunctionToolUpdateSchema = FunctionToolUpdateSchema;
-exports.FunctionUpdateSchema = FunctionUpdateSchema;
-exports.HeadersScopeSchema = HeadersScopeSchema;
-exports.LedgerArtifactApiInsertSchema = LedgerArtifactApiInsertSchema;
-exports.LedgerArtifactApiSelectSchema = LedgerArtifactApiSelectSchema;
-exports.LedgerArtifactApiUpdateSchema = LedgerArtifactApiUpdateSchema;
-exports.LedgerArtifactInsertSchema = LedgerArtifactInsertSchema;
-exports.LedgerArtifactSelectSchema = LedgerArtifactSelectSchema;
-exports.LedgerArtifactUpdateSchema = LedgerArtifactUpdateSchema;
-exports.ListResponseSchema = ListResponseSchema;
-exports.MAX_ID_LENGTH = MAX_ID_LENGTH;
-exports.MCPToolConfigSchema = MCPToolConfigSchema;
-exports.MIN_ID_LENGTH = MIN_ID_LENGTH;
-exports.McpToolDefinitionSchema = McpToolDefinitionSchema;
-exports.McpToolListResponse = McpToolListResponse;
-exports.McpToolResponse = McpToolResponse;
-exports.McpToolSchema = McpToolSchema;
-exports.McpTransportConfigSchema = McpTransportConfigSchema;
-exports.MessageApiInsertSchema = MessageApiInsertSchema;
-exports.MessageApiSelectSchema = MessageApiSelectSchema;
-exports.MessageApiUpdateSchema = MessageApiUpdateSchema;
-exports.MessageInsertSchema = MessageInsertSchema;
-exports.MessageListResponse = MessageListResponse;
-exports.MessageResponse = MessageResponse;
-exports.MessageSelectSchema = MessageSelectSchema;
-exports.MessageUpdateSchema = MessageUpdateSchema;
-exports.ModelSchema = ModelSchema;
-exports.ModelSettingsSchema = ModelSettingsSchema;
-exports.OAuthCallbackQuerySchema = OAuthCallbackQuerySchema;
-exports.OAuthLoginQuerySchema = OAuthLoginQuerySchema;
-exports.PaginationQueryParamsSchema = PaginationQueryParamsSchema;
-exports.PaginationSchema = PaginationSchema;
-exports.ProjectApiInsertSchema = ProjectApiInsertSchema;
-exports.ProjectApiSelectSchema = ProjectApiSelectSchema;
-exports.ProjectApiUpdateSchema = ProjectApiUpdateSchema;
-exports.ProjectInsertSchema = ProjectInsertSchema;
-exports.ProjectListResponse = ProjectListResponse;
-exports.ProjectModelSchema = ProjectModelSchema;
-exports.ProjectResponse = ProjectResponse;
-exports.ProjectSelectSchema = ProjectSelectSchema;
-exports.ProjectUpdateSchema = ProjectUpdateSchema;
-exports.RelatedAgentInfoListResponse = RelatedAgentInfoListResponse;
-exports.RelatedAgentInfoSchema = RelatedAgentInfoSchema;
-exports.RemovedResponseSchema = RemovedResponseSchema;
-exports.SingleResponseSchema = SingleResponseSchema;
-exports.StatusComponentSchema = StatusComponentSchema;
-exports.StatusUpdateSchema = StatusUpdateSchema;
-exports.StopWhenSchema = StopWhenSchema;
-exports.StreamErrorEventSchema = StreamErrorEventSchema;
-exports.StreamEventSchema = StreamEventSchema;
-exports.StreamFinishEventSchema = StreamFinishEventSchema;
-exports.SubAgentApiInsertSchema = SubAgentApiInsertSchema;
-exports.SubAgentApiSelectSchema = SubAgentApiSelectSchema;
-exports.SubAgentApiUpdateSchema = SubAgentApiUpdateSchema;
-exports.SubAgentArtifactComponentApiInsertSchema = SubAgentArtifactComponentApiInsertSchema;
-exports.SubAgentArtifactComponentApiSelectSchema = SubAgentArtifactComponentApiSelectSchema;
-exports.SubAgentArtifactComponentApiUpdateSchema = SubAgentArtifactComponentApiUpdateSchema;
-exports.SubAgentArtifactComponentInsertSchema = SubAgentArtifactComponentInsertSchema;
-exports.SubAgentArtifactComponentListResponse = SubAgentArtifactComponentListResponse;
-exports.SubAgentArtifactComponentResponse = SubAgentArtifactComponentResponse;
-exports.SubAgentArtifactComponentSelectSchema = SubAgentArtifactComponentSelectSchema;
-exports.SubAgentArtifactComponentUpdateSchema = SubAgentArtifactComponentUpdateSchema;
-exports.SubAgentDataComponentApiInsertSchema = SubAgentDataComponentApiInsertSchema;
-exports.SubAgentDataComponentApiSelectSchema = SubAgentDataComponentApiSelectSchema;
-exports.SubAgentDataComponentApiUpdateSchema = SubAgentDataComponentApiUpdateSchema;
-exports.SubAgentDataComponentInsertSchema = SubAgentDataComponentInsertSchema;
-exports.SubAgentDataComponentListResponse = SubAgentDataComponentListResponse;
-exports.SubAgentDataComponentResponse = SubAgentDataComponentResponse;
-exports.SubAgentDataComponentSelectSchema = SubAgentDataComponentSelectSchema;
-exports.SubAgentDataComponentUpdateSchema = SubAgentDataComponentUpdateSchema;
-exports.SubAgentExternalAgentRelationApiInsertSchema = SubAgentExternalAgentRelationApiInsertSchema;
-exports.SubAgentExternalAgentRelationApiSelectSchema = SubAgentExternalAgentRelationApiSelectSchema;
-exports.SubAgentExternalAgentRelationApiUpdateSchema = SubAgentExternalAgentRelationApiUpdateSchema;
-exports.SubAgentExternalAgentRelationInsertSchema = SubAgentExternalAgentRelationInsertSchema;
-exports.SubAgentExternalAgentRelationListResponse = SubAgentExternalAgentRelationListResponse;
-exports.SubAgentExternalAgentRelationResponse = SubAgentExternalAgentRelationResponse;
-exports.SubAgentExternalAgentRelationSelectSchema = SubAgentExternalAgentRelationSelectSchema;
-exports.SubAgentExternalAgentRelationUpdateSchema = SubAgentExternalAgentRelationUpdateSchema;
-exports.SubAgentInsertSchema = SubAgentInsertSchema;
-exports.SubAgentListResponse = SubAgentListResponse;
-exports.SubAgentRelationApiInsertSchema = SubAgentRelationApiInsertSchema;
-exports.SubAgentRelationApiSelectSchema = SubAgentRelationApiSelectSchema;
-exports.SubAgentRelationApiUpdateSchema = SubAgentRelationApiUpdateSchema;
-exports.SubAgentRelationInsertSchema = SubAgentRelationInsertSchema;
-exports.SubAgentRelationListResponse = SubAgentRelationListResponse;
-exports.SubAgentRelationQuerySchema = SubAgentRelationQuerySchema;
-exports.SubAgentRelationResponse = SubAgentRelationResponse;
-exports.SubAgentRelationSelectSchema = SubAgentRelationSelectSchema;
-exports.SubAgentRelationUpdateSchema = SubAgentRelationUpdateSchema;
-exports.SubAgentResponse = SubAgentResponse;
-exports.SubAgentSelectSchema = SubAgentSelectSchema;
-exports.SubAgentStopWhenSchema = SubAgentStopWhenSchema;
-exports.SubAgentTeamAgentRelationApiInsertSchema = SubAgentTeamAgentRelationApiInsertSchema;
-exports.SubAgentTeamAgentRelationApiSelectSchema = SubAgentTeamAgentRelationApiSelectSchema;
-exports.SubAgentTeamAgentRelationApiUpdateSchema = SubAgentTeamAgentRelationApiUpdateSchema;
-exports.SubAgentTeamAgentRelationInsertSchema = SubAgentTeamAgentRelationInsertSchema;
-exports.SubAgentTeamAgentRelationListResponse = SubAgentTeamAgentRelationListResponse;
-exports.SubAgentTeamAgentRelationResponse = SubAgentTeamAgentRelationResponse;
-exports.SubAgentTeamAgentRelationSelectSchema = SubAgentTeamAgentRelationSelectSchema;
-exports.SubAgentTeamAgentRelationUpdateSchema = SubAgentTeamAgentRelationUpdateSchema;
-exports.SubAgentToolRelationApiInsertSchema = SubAgentToolRelationApiInsertSchema;
-exports.SubAgentToolRelationApiSelectSchema = SubAgentToolRelationApiSelectSchema;
-exports.SubAgentToolRelationApiUpdateSchema = SubAgentToolRelationApiUpdateSchema;
-exports.SubAgentToolRelationInsertSchema = SubAgentToolRelationInsertSchema;
-exports.SubAgentToolRelationListResponse = SubAgentToolRelationListResponse;
-exports.SubAgentToolRelationResponse = SubAgentToolRelationResponse;
-exports.SubAgentToolRelationSelectSchema = SubAgentToolRelationSelectSchema;
-exports.SubAgentToolRelationUpdateSchema = SubAgentToolRelationUpdateSchema;
-exports.SubAgentUpdateSchema = SubAgentUpdateSchema;
-exports.TaskApiInsertSchema = TaskApiInsertSchema;
-exports.TaskApiSelectSchema = TaskApiSelectSchema;
-exports.TaskApiUpdateSchema = TaskApiUpdateSchema;
-exports.TaskInsertSchema = TaskInsertSchema;
-exports.TaskRelationApiInsertSchema = TaskRelationApiInsertSchema;
-exports.TaskRelationApiSelectSchema = TaskRelationApiSelectSchema;
-exports.TaskRelationApiUpdateSchema = TaskRelationApiUpdateSchema;
-exports.TaskRelationInsertSchema = TaskRelationInsertSchema;
-exports.TaskRelationSelectSchema = TaskRelationSelectSchema;
-exports.TaskRelationUpdateSchema = TaskRelationUpdateSchema;
-exports.TaskSelectSchema = TaskSelectSchema;
-exports.TaskUpdateSchema = TaskUpdateSchema;
-exports.TeamAgentSchema = TeamAgentSchema;
-exports.TenantIdParamsSchema = TenantIdParamsSchema;
-exports.TenantParamsSchema = TenantParamsSchema;
-exports.TenantProjectAgentIdParamsSchema = TenantProjectAgentIdParamsSchema;
-exports.TenantProjectAgentParamsSchema = TenantProjectAgentParamsSchema;
-exports.TenantProjectAgentSubAgentIdParamsSchema = TenantProjectAgentSubAgentIdParamsSchema;
-exports.TenantProjectAgentSubAgentParamsSchema = TenantProjectAgentSubAgentParamsSchema;
-exports.TenantProjectIdParamsSchema = TenantProjectIdParamsSchema;
-exports.TenantProjectParamsSchema = TenantProjectParamsSchema;
-exports.TextDeltaEventSchema = TextDeltaEventSchema;
-exports.TextEndEventSchema = TextEndEventSchema;
-exports.TextStartEventSchema = TextStartEventSchema;
-exports.ToolApiInsertSchema = ToolApiInsertSchema;
-exports.ToolApiSelectSchema = ToolApiSelectSchema;
-exports.ToolApiUpdateSchema = ToolApiUpdateSchema;
-exports.ToolInsertSchema = ToolInsertSchema;
-exports.ToolListResponse = ToolListResponse;
-exports.ToolResponse = ToolResponse;
-exports.ToolSelectSchema = ToolSelectSchema;
-exports.ToolStatusSchema = ToolStatusSchema;
-exports.ToolUpdateSchema = ToolUpdateSchema;
-exports.TransferDataSchema = TransferDataSchema;
-exports.URL_SAFE_ID_PATTERN = URL_SAFE_ID_PATTERN;
-exports.canDelegateToExternalAgentSchema = canDelegateToExternalAgentSchema;
-exports.canDelegateToTeamAgentSchema = canDelegateToTeamAgentSchema;
-exports.generateIdFromName = generateIdFromName;
-exports.isValidResourceId = isValidResourceId;
-exports.resourceIdSchema = resourceIdSchema;
-exports.validateAgentRelationships = validateAgentRelationships;
-exports.validateAgentStructure = validateAgentStructure;
-exports.validateAndTypeAgentData = validateAndTypeAgentData;
-exports.validateArtifactComponentReferences = validateArtifactComponentReferences;
-exports.validateDataComponentReferences = validateDataComponentReferences;
-exports.validatePropsAsJsonSchema = validatePropsAsJsonSchema;
-exports.validateRender = validateRender;
-exports.validateSubAgentExternalAgentRelations = validateSubAgentExternalAgentRelations;
-exports.validateToolReferences = validateToolReferences;