@inkeep/agents-core 0.0.0-chat-to-edit-20251119071712

package/dist/validation/index.cjs

@@ -0,0 +1,3521 @@
+'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 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] })]
+);
+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(),
+    toolPolicies: pgCore.jsonb("tool_policies").$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, 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")
+  ]
+);
+var dataset = pgCore.pgTable(
+  "dataset",
+  {
+    ...projectScoped,
+    ...uiProperties,
+    ...timestamps
+  },
+  (table) => [
+    pgCore.primaryKey({ columns: [table.tenantId, table.projectId, table.id] }),
+    pgCore.foreignKey({
+      columns: [table.tenantId, table.projectId],
+      foreignColumns: [projects.tenantId, projects.id],
+      name: "dataset_project_fk"
+    }).onDelete("cascade")
+  ]
+);
+var datasetItem = pgCore.pgTable(
+  "dataset_item",
+  {
+    ...projectScoped,
+    datasetId: pgCore.text("dataset_id").notNull(),
+    input: pgCore.jsonb("input").$type().notNull(),
+    expectedOutput: pgCore.jsonb("expected_output").$type(),
+    simulationAgent: pgCore.jsonb("simulation_agent").$type(),
+    ...timestamps
+  },
+  (table) => [
+    pgCore.primaryKey({ columns: [table.tenantId, table.projectId, table.id] }),
+    pgCore.foreignKey({
+      columns: [table.tenantId, table.projectId, table.datasetId],
+      foreignColumns: [dataset.tenantId, dataset.projectId, dataset.id],
+      name: "dataset_item_dataset_fk"
+    }).onDelete("cascade")
+  ]
+);
+var evaluator = pgCore.pgTable(
+  "evaluator",
+  {
+    ...projectScoped,
+    ...uiProperties,
+    prompt: pgCore.text("prompt").notNull(),
+    schema: pgCore.jsonb("schema").$type().notNull(),
+    model: pgCore.jsonb("model").$type().notNull(),
+    passCriteria: pgCore.jsonb("pass_criteria").$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: "evaluator_project_fk"
+    }).onDelete("cascade")
+  ]
+);
+var datasetRunConfig = pgCore.pgTable(
+  "dataset_run_config",
+  {
+    ...projectScoped,
+    ...uiProperties,
+    datasetId: pgCore.text("dataset_id").notNull(),
+    ...timestamps
+  },
+  (table) => [
+    pgCore.primaryKey({ columns: [table.tenantId, table.projectId, table.id] }),
+    pgCore.foreignKey({
+      columns: [table.tenantId, table.projectId],
+      foreignColumns: [projects.tenantId, projects.id],
+      name: "dataset_run_config_project_fk"
+    }).onDelete("cascade"),
+    pgCore.foreignKey({
+      columns: [table.tenantId, table.projectId, table.datasetId],
+      foreignColumns: [dataset.tenantId, dataset.projectId, dataset.id],
+      name: "dataset_run_config_dataset_fk"
+    }).onDelete("cascade")
+  ]
+);
+var datasetRunConfigAgentRelations = pgCore.pgTable(
+  "dataset_run_config_agent_relations",
+  {
+    ...projectScoped,
+    datasetRunConfigId: pgCore.text("dataset_run_config_id").notNull(),
+    agentId: pgCore.text("agent_id").notNull(),
+    ...timestamps
+  },
+  (table) => [
+    pgCore.primaryKey({ columns: [table.tenantId, table.projectId, table.id] }),
+    pgCore.foreignKey({
+      columns: [table.tenantId, table.projectId, table.datasetRunConfigId],
+      foreignColumns: [datasetRunConfig.tenantId, datasetRunConfig.projectId, datasetRunConfig.id],
+      name: "dataset_run_config_agent_relations_dataset_run_config_fk"
+    }).onDelete("cascade"),
+    pgCore.foreignKey({
+      columns: [table.tenantId, table.projectId, table.agentId],
+      foreignColumns: [agents.tenantId, agents.projectId, agents.id],
+      name: "dataset_run_config_agent_relations_agent_fk"
+    }).onDelete("cascade")
+  ]
+);
+var datasetRunConfigEvaluationRunConfigRelations = pgCore.pgTable(
+  "dataset_run_config_evaluation_run_config_relations",
+  {
+    ...projectScoped,
+    datasetRunConfigId: pgCore.text("dataset_run_config_id").notNull(),
+    evaluationRunConfigId: pgCore.text("evaluation_run_config_id").notNull(),
+    enabled: pgCore.boolean("enabled").notNull().default(true),
+    ...timestamps
+  },
+  (table) => [
+    pgCore.primaryKey({ columns: [table.tenantId, table.projectId, table.id] }),
+    pgCore.foreignKey({
+      columns: [table.tenantId, table.projectId, table.datasetRunConfigId],
+      foreignColumns: [datasetRunConfig.tenantId, datasetRunConfig.projectId, datasetRunConfig.id],
+      name: "dataset_run_config_evaluation_run_config_relations_dataset_run_config_fk"
+    }).onDelete("cascade"),
+    pgCore.foreignKey({
+      columns: [table.tenantId, table.projectId, table.evaluationRunConfigId],
+      foreignColumns: [
+        evaluationRunConfig.tenantId,
+        evaluationRunConfig.projectId,
+        evaluationRunConfig.id
+      ],
+      name: "dataset_run_config_evaluation_run_config_relations_evaluation_run_config_fk"
+    }).onDelete("cascade")
+  ]
+);
+var datasetRun = pgCore.pgTable(
+  "dataset_run",
+  {
+    ...projectScoped,
+    datasetId: pgCore.text("dataset_id").notNull(),
+    datasetRunConfigId: pgCore.text("dataset_run_config_id").notNull(),
+    evaluationJobConfigId: pgCore.text("evaluation_job_config_id"),
+    ...timestamps
+  },
+  (table) => [
+    pgCore.primaryKey({ columns: [table.tenantId, table.projectId, table.id] }),
+    pgCore.foreignKey({
+      columns: [table.tenantId, table.projectId, table.datasetId],
+      foreignColumns: [dataset.tenantId, dataset.projectId, dataset.id],
+      name: "dataset_run_dataset_fk"
+    }).onDelete("cascade"),
+    pgCore.foreignKey({
+      columns: [table.tenantId, table.projectId, table.datasetRunConfigId],
+      foreignColumns: [datasetRunConfig.tenantId, datasetRunConfig.projectId, datasetRunConfig.id],
+      name: "dataset_run_dataset_run_config_fk"
+    }).onDelete("cascade"),
+    pgCore.foreignKey({
+      columns: [table.tenantId, table.projectId, table.evaluationJobConfigId],
+      foreignColumns: [
+        evaluationJobConfig.tenantId,
+        evaluationJobConfig.projectId,
+        evaluationJobConfig.id
+      ],
+      name: "dataset_run_evaluation_job_config_fk"
+    }).onDelete("set null")
+  ]
+);
+var datasetRunConversationRelations = pgCore.pgTable(
+  "dataset_run_conversation_relations",
+  {
+    ...projectScoped,
+    datasetRunId: pgCore.text("dataset_run_id").notNull(),
+    conversationId: pgCore.text("conversation_id").notNull(),
+    datasetItemId: pgCore.text("dataset_item_id").notNull(),
+    ...timestamps
+  },
+  (table) => [
+    pgCore.primaryKey({ columns: [table.tenantId, table.projectId, table.id] }),
+    pgCore.foreignKey({
+      columns: [table.tenantId, table.projectId, table.datasetRunId],
+      foreignColumns: [datasetRun.tenantId, datasetRun.projectId, datasetRun.id],
+      name: "dataset_run_conversation_relations_run_fk"
+    }).onDelete("cascade"),
+    pgCore.foreignKey({
+      columns: [table.tenantId, table.projectId, table.conversationId],
+      foreignColumns: [conversations.tenantId, conversations.projectId, conversations.id],
+      name: "dataset_run_conversation_relations_conversation_fk"
+    }).onDelete("cascade"),
+    pgCore.foreignKey({
+      columns: [table.tenantId, table.projectId, table.datasetItemId],
+      foreignColumns: [datasetItem.tenantId, datasetItem.projectId, datasetItem.id],
+      name: "dataset_run_conversation_relations_item_fk"
+    }).onDelete("cascade"),
+    pgCore.unique("dataset_run_conversation_relations_unique").on(
+      table.datasetRunId,
+      table.conversationId
+    )
+  ]
+);
+var evaluationSuiteConfig = pgCore.pgTable(
+  "evaluation_suite_config",
+  {
+    ...projectScoped,
+    ...uiProperties,
+    filters: pgCore.jsonb("filters").$type(),
+    // Filters for the evaluation suite (supports and/or operations)
+    sampleRate: pgCore.doublePrecision("sample_rate"),
+    ...timestamps
+  },
+  (table) => [
+    pgCore.primaryKey({ columns: [table.tenantId, table.projectId, table.id] }),
+    pgCore.foreignKey({
+      columns: [table.tenantId, table.projectId],
+      foreignColumns: [projects.tenantId, projects.id],
+      name: "evaluation_suite_config_project_fk"
+    }).onDelete("cascade")
+  ]
+);
+var evaluationSuiteConfigEvaluatorRelations = pgCore.pgTable(
+  "evaluation_suite_config_evaluator_relations",
+  {
+    ...projectScoped,
+    evaluationSuiteConfigId: pgCore.text("evaluation_suite_config_id").notNull(),
+    evaluatorId: pgCore.text("evaluator_id").notNull(),
+    ...timestamps
+  },
+  (table) => [
+    pgCore.primaryKey({ columns: [table.tenantId, table.projectId, table.id] }),
+    pgCore.foreignKey({
+      columns: [table.tenantId, table.projectId, table.evaluationSuiteConfigId],
+      foreignColumns: [
+        evaluationSuiteConfig.tenantId,
+        evaluationSuiteConfig.projectId,
+        evaluationSuiteConfig.id
+      ],
+      name: "evaluation_suite_config_evaluator_relations_evaluation_suite_config_fk"
+    }).onDelete("cascade"),
+    pgCore.foreignKey({
+      columns: [table.tenantId, table.projectId, table.evaluatorId],
+      foreignColumns: [evaluator.tenantId, evaluator.projectId, evaluator.id],
+      name: "evaluation_suite_config_evaluator_relations_evaluator_fk"
+    }).onDelete("cascade")
+  ]
+);
+var evaluationRunConfig = pgCore.pgTable(
+  "evaluation_run_config",
+  {
+    ...projectScoped,
+    ...uiProperties,
+    isActive: pgCore.boolean("is_active").notNull().default(true),
+    ...timestamps
+  },
+  (table) => [
+    pgCore.primaryKey({ columns: [table.tenantId, table.projectId, table.id] }),
+    pgCore.foreignKey({
+      columns: [table.tenantId, table.projectId],
+      foreignColumns: [projects.tenantId, projects.id],
+      name: "evaluation_run_config_project_fk"
+    }).onDelete("cascade")
+  ]
+);
+var evaluationRunConfigEvaluationSuiteConfigRelations = pgCore.pgTable(
+  "evaluation_run_config_evaluation_suite_config_relations",
+  {
+    ...projectScoped,
+    evaluationRunConfigId: pgCore.text("evaluation_run_config_id").notNull(),
+    evaluationSuiteConfigId: pgCore.text("evaluation_suite_config_id").notNull(),
+    ...timestamps
+  },
+  (table) => [
+    pgCore.primaryKey({ columns: [table.tenantId, table.projectId, table.id] }),
+    pgCore.foreignKey({
+      columns: [table.tenantId, table.projectId, table.evaluationRunConfigId],
+      foreignColumns: [
+        evaluationRunConfig.tenantId,
+        evaluationRunConfig.projectId,
+        evaluationRunConfig.id
+      ],
+      name: "eval_run_config_eval_suite_rel_run_config_fk"
+    }).onDelete("cascade"),
+    pgCore.foreignKey({
+      columns: [table.tenantId, table.projectId, table.evaluationSuiteConfigId],
+      foreignColumns: [
+        evaluationSuiteConfig.tenantId,
+        evaluationSuiteConfig.projectId,
+        evaluationSuiteConfig.id
+      ],
+      name: "eval_run_config_eval_suite_rel_suite_config_fk"
+    }).onDelete("cascade")
+  ]
+);
+var evaluationJobConfig = pgCore.pgTable(
+  "evaluation_job_config",
+  {
+    ...projectScoped,
+    jobFilters: pgCore.jsonb("job_filters").$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: "evaluation_job_config_project_fk"
+    }).onDelete("cascade")
+  ]
+);
+var evaluationJobConfigEvaluatorRelations = pgCore.pgTable(
+  "evaluation_job_config_evaluator_relations",
+  {
+    ...projectScoped,
+    evaluationJobConfigId: pgCore.text("evaluation_job_config_id").notNull(),
+    evaluatorId: pgCore.text("evaluator_id").notNull(),
+    ...timestamps
+  },
+  (table) => [
+    pgCore.primaryKey({ columns: [table.tenantId, table.projectId, table.id] }),
+    pgCore.foreignKey({
+      columns: [table.tenantId, table.projectId, table.evaluationJobConfigId],
+      foreignColumns: [
+        evaluationJobConfig.tenantId,
+        evaluationJobConfig.projectId,
+        evaluationJobConfig.id
+      ],
+      name: "evaluation_job_config_evaluator_relations_evaluation_job_config_fk"
+    }).onDelete("cascade"),
+    pgCore.foreignKey({
+      columns: [table.tenantId, table.projectId, table.evaluatorId],
+      foreignColumns: [evaluator.tenantId, evaluator.projectId, evaluator.id],
+      name: "evaluation_job_config_evaluator_relations_evaluator_fk"
+    }).onDelete("cascade")
+  ]
+);
+var evaluationRun = pgCore.pgTable(
+  "evaluation_run",
+  {
+    ...projectScoped,
+    evaluationJobConfigId: pgCore.text("evaluation_job_config_id"),
+    // Optional: if created from a job
+    evaluationRunConfigId: pgCore.text("evaluation_run_config_id"),
+    // Optional: if created from a run config
+    ...timestamps
+  },
+  (table) => [
+    pgCore.primaryKey({ columns: [table.tenantId, table.projectId, table.id] }),
+    pgCore.foreignKey({
+      columns: [table.tenantId, table.projectId, table.evaluationJobConfigId],
+      foreignColumns: [
+        evaluationJobConfig.tenantId,
+        evaluationJobConfig.projectId,
+        evaluationJobConfig.id
+      ],
+      name: "evaluation_run_evaluation_job_config_fk"
+    }).onDelete("cascade"),
+    pgCore.foreignKey({
+      columns: [table.tenantId, table.projectId, table.evaluationRunConfigId],
+      foreignColumns: [
+        evaluationRunConfig.tenantId,
+        evaluationRunConfig.projectId,
+        evaluationRunConfig.id
+      ],
+      name: "evaluation_run_evaluation_run_config_fk"
+    }).onDelete("cascade")
+  ]
+);
+var evaluationResult = pgCore.pgTable(
+  "evaluation_result",
+  {
+    ...projectScoped,
+    conversationId: pgCore.text("conversation_id").notNull(),
+    evaluatorId: pgCore.text("evaluator_id").notNull(),
+    evaluationRunId: pgCore.text("evaluation_run_id"),
+    output: pgCore.jsonb("output").$type(),
+    ...timestamps
+  },
+  (table) => [
+    pgCore.primaryKey({ columns: [table.tenantId, table.projectId, table.id] }),
+    pgCore.foreignKey({
+      columns: [table.tenantId, table.projectId, table.conversationId],
+      foreignColumns: [conversations.tenantId, conversations.projectId, conversations.id],
+      name: "evaluation_result_conversation_fk"
+    }).onDelete("cascade"),
+    pgCore.foreignKey({
+      columns: [table.tenantId, table.projectId, table.evaluatorId],
+      foreignColumns: [evaluator.tenantId, evaluator.projectId, evaluator.id],
+      name: "evaluation_result_evaluator_fk"
+    }).onDelete("cascade"),
+    pgCore.foreignKey({
+      columns: [table.tenantId, table.projectId, table.evaluationRunId],
+      foreignColumns: [evaluationRun.tenantId, evaluationRun.projectId, evaluationRun.id],
+      name: "evaluation_result_evaluation_run_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),
+  datasets: many(dataset),
+  evaluators: many(evaluator),
+  evaluationSuiteConfigs: many(evaluationSuiteConfig),
+  datasetRunConfigs: many(datasetRunConfig)
+}));
+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]
+    })
+  })
+);
+drizzleOrm.relations(dataset, ({ one, many }) => ({
+  project: one(projects, {
+    fields: [dataset.tenantId, dataset.projectId],
+    references: [projects.tenantId, projects.id]
+  }),
+  items: many(datasetItem),
+  datasetRuns: many(datasetRun)
+}));
+drizzleOrm.relations(datasetItem, ({ one }) => ({
+  dataset: one(dataset, {
+    fields: [datasetItem.tenantId, datasetItem.projectId, datasetItem.datasetId],
+    references: [dataset.tenantId, dataset.projectId, dataset.id]
+  })
+}));
+drizzleOrm.relations(evaluator, ({ one, many }) => ({
+  project: one(projects, {
+    fields: [evaluator.tenantId, evaluator.projectId],
+    references: [projects.tenantId, projects.id]
+  }),
+  evaluationResults: many(evaluationResult),
+  evaluationSuiteConfigs: many(evaluationSuiteConfigEvaluatorRelations),
+  evaluationJobConfigs: many(evaluationJobConfigEvaluatorRelations)
+}));
+drizzleOrm.relations(datasetRunConfig, ({ one, many }) => ({
+  project: one(projects, {
+    fields: [datasetRunConfig.tenantId, datasetRunConfig.projectId],
+    references: [projects.tenantId, projects.id]
+  }),
+  dataset: one(dataset, {
+    fields: [datasetRunConfig.tenantId, datasetRunConfig.projectId, datasetRunConfig.datasetId],
+    references: [dataset.tenantId, dataset.projectId, dataset.id]
+  }),
+  agents: many(datasetRunConfigAgentRelations),
+  evaluationRunConfigs: many(datasetRunConfigEvaluationRunConfigRelations),
+  runs: many(datasetRun)
+}));
+drizzleOrm.relations(
+  datasetRunConfigAgentRelations,
+  ({ one }) => ({
+    datasetRunConfig: one(datasetRunConfig, {
+      fields: [
+        datasetRunConfigAgentRelations.tenantId,
+        datasetRunConfigAgentRelations.projectId,
+        datasetRunConfigAgentRelations.datasetRunConfigId
+      ],
+      references: [datasetRunConfig.tenantId, datasetRunConfig.projectId, datasetRunConfig.id]
+    }),
+    agent: one(agents, {
+      fields: [
+        datasetRunConfigAgentRelations.tenantId,
+        datasetRunConfigAgentRelations.projectId,
+        datasetRunConfigAgentRelations.agentId
+      ],
+      references: [agents.tenantId, agents.projectId, agents.id]
+    })
+  })
+);
+drizzleOrm.relations(
+  datasetRunConfigEvaluationRunConfigRelations,
+  ({ one }) => ({
+    datasetRunConfig: one(datasetRunConfig, {
+      fields: [
+        datasetRunConfigEvaluationRunConfigRelations.tenantId,
+        datasetRunConfigEvaluationRunConfigRelations.projectId,
+        datasetRunConfigEvaluationRunConfigRelations.datasetRunConfigId
+      ],
+      references: [datasetRunConfig.tenantId, datasetRunConfig.projectId, datasetRunConfig.id]
+    }),
+    evaluationRunConfig: one(evaluationRunConfig, {
+      fields: [
+        datasetRunConfigEvaluationRunConfigRelations.tenantId,
+        datasetRunConfigEvaluationRunConfigRelations.projectId,
+        datasetRunConfigEvaluationRunConfigRelations.evaluationRunConfigId
+      ],
+      references: [
+        evaluationRunConfig.tenantId,
+        evaluationRunConfig.projectId,
+        evaluationRunConfig.id
+      ]
+    })
+  })
+);
+drizzleOrm.relations(datasetRun, ({ one, many }) => ({
+  dataset: one(dataset, {
+    fields: [datasetRun.tenantId, datasetRun.projectId, datasetRun.datasetId],
+    references: [dataset.tenantId, dataset.projectId, dataset.id]
+  }),
+  datasetRunConfig: one(datasetRunConfig, {
+    fields: [datasetRun.tenantId, datasetRun.projectId, datasetRun.datasetRunConfigId],
+    references: [datasetRunConfig.tenantId, datasetRunConfig.projectId, datasetRunConfig.id]
+  }),
+  conversations: many(datasetRunConversationRelations)
+}));
+drizzleOrm.relations(evaluationSuiteConfig, ({ one, many }) => ({
+  project: one(projects, {
+    fields: [evaluationSuiteConfig.tenantId, evaluationSuiteConfig.projectId],
+    references: [projects.tenantId, projects.id]
+  }),
+  runConfigs: many(evaluationRunConfigEvaluationSuiteConfigRelations),
+  evaluators: many(evaluationSuiteConfigEvaluatorRelations)
+}));
+drizzleOrm.relations(
+  evaluationSuiteConfigEvaluatorRelations,
+  ({ one }) => ({
+    evaluationSuiteConfig: one(evaluationSuiteConfig, {
+      fields: [
+        evaluationSuiteConfigEvaluatorRelations.tenantId,
+        evaluationSuiteConfigEvaluatorRelations.projectId,
+        evaluationSuiteConfigEvaluatorRelations.evaluationSuiteConfigId
+      ],
+      references: [
+        evaluationSuiteConfig.tenantId,
+        evaluationSuiteConfig.projectId,
+        evaluationSuiteConfig.id
+      ]
+    }),
+    evaluator: one(evaluator, {
+      fields: [
+        evaluationSuiteConfigEvaluatorRelations.tenantId,
+        evaluationSuiteConfigEvaluatorRelations.projectId,
+        evaluationSuiteConfigEvaluatorRelations.evaluatorId
+      ],
+      references: [evaluator.tenantId, evaluator.projectId, evaluator.id]
+    })
+  })
+);
+drizzleOrm.relations(
+  evaluationJobConfigEvaluatorRelations,
+  ({ one }) => ({
+    evaluationJobConfig: one(evaluationJobConfig, {
+      fields: [
+        evaluationJobConfigEvaluatorRelations.tenantId,
+        evaluationJobConfigEvaluatorRelations.projectId,
+        evaluationJobConfigEvaluatorRelations.evaluationJobConfigId
+      ],
+      references: [
+        evaluationJobConfig.tenantId,
+        evaluationJobConfig.projectId,
+        evaluationJobConfig.id
+      ]
+    }),
+    evaluator: one(evaluator, {
+      fields: [
+        evaluationJobConfigEvaluatorRelations.tenantId,
+        evaluationJobConfigEvaluatorRelations.projectId,
+        evaluationJobConfigEvaluatorRelations.evaluatorId
+      ],
+      references: [evaluator.tenantId, evaluator.projectId, evaluator.id]
+    })
+  })
+);
+drizzleOrm.relations(evaluationJobConfig, ({ one, many }) => ({
+  project: one(projects, {
+    fields: [evaluationJobConfig.tenantId, evaluationJobConfig.projectId],
+    references: [projects.tenantId, projects.id]
+  }),
+  run: one(evaluationRun, {
+    fields: [evaluationJobConfig.tenantId, evaluationJobConfig.projectId, evaluationJobConfig.id],
+    references: [
+      evaluationRun.tenantId,
+      evaluationRun.projectId,
+      evaluationRun.evaluationJobConfigId
+    ]
+  }),
+  evaluators: many(evaluationJobConfigEvaluatorRelations)
+}));
+drizzleOrm.relations(
+  evaluationRunConfigEvaluationSuiteConfigRelations,
+  ({ one }) => ({
+    evaluationRunConfig: one(evaluationRunConfig, {
+      fields: [
+        evaluationRunConfigEvaluationSuiteConfigRelations.tenantId,
+        evaluationRunConfigEvaluationSuiteConfigRelations.projectId,
+        evaluationRunConfigEvaluationSuiteConfigRelations.evaluationRunConfigId
+      ],
+      references: [
+        evaluationRunConfig.tenantId,
+        evaluationRunConfig.projectId,
+        evaluationRunConfig.id
+      ]
+    }),
+    evaluationSuiteConfig: one(evaluationSuiteConfig, {
+      fields: [
+        evaluationRunConfigEvaluationSuiteConfigRelations.tenantId,
+        evaluationRunConfigEvaluationSuiteConfigRelations.projectId,
+        evaluationRunConfigEvaluationSuiteConfigRelations.evaluationSuiteConfigId
+      ],
+      references: [
+        evaluationSuiteConfig.tenantId,
+        evaluationSuiteConfig.projectId,
+        evaluationSuiteConfig.id
+      ]
+    })
+  })
+);
+drizzleOrm.relations(evaluationRunConfig, ({ one, many }) => ({
+  project: one(projects, {
+    fields: [evaluationRunConfig.tenantId, evaluationRunConfig.projectId],
+    references: [projects.tenantId, projects.id]
+  }),
+  suiteConfigs: many(evaluationRunConfigEvaluationSuiteConfigRelations),
+  datasetRunConfigs: many(datasetRunConfigEvaluationRunConfigRelations),
+  runs: many(evaluationRun)
+}));
+drizzleOrm.relations(evaluationRun, ({ one, many }) => ({
+  evaluationJobConfig: one(evaluationJobConfig, {
+    fields: [evaluationRun.tenantId, evaluationRun.projectId, evaluationRun.evaluationJobConfigId],
+    references: [
+      evaluationJobConfig.tenantId,
+      evaluationJobConfig.projectId,
+      evaluationJobConfig.id
+    ]
+  }),
+  evaluationRunConfig: one(evaluationRunConfig, {
+    fields: [evaluationRun.tenantId, evaluationRun.projectId, evaluationRun.evaluationRunConfigId],
+    references: [
+      evaluationRunConfig.tenantId,
+      evaluationRunConfig.projectId,
+      evaluationRunConfig.id
+    ]
+  }),
+  results: many(evaluationResult)
+}));
+drizzleOrm.relations(evaluationResult, ({ one }) => ({
+  conversation: one(conversations, {
+    fields: [
+      evaluationResult.tenantId,
+      evaluationResult.projectId,
+      evaluationResult.conversationId
+    ],
+    references: [conversations.tenantId, conversations.projectId, conversations.id],
+    relationName: "conversationEvaluationResults"
+  }),
+  evaluator: one(evaluator, {
+    fields: [evaluationResult.tenantId, evaluationResult.projectId, evaluationResult.evaluatorId],
+    references: [evaluator.tenantId, evaluator.projectId, evaluator.id]
+  }),
+  evaluationRun: one(evaluationRun, {
+    fields: [
+      evaluationResult.tenantId,
+      evaluationResult.projectId,
+      evaluationResult.evaluationRunId
+    ],
+    references: [evaluationRun.tenantId, evaluationRun.projectId, evaluationRun.id]
+  })
+}));
+drizzleOrm.relations(conversations, ({ many }) => ({
+  evaluationResults: many(evaluationResult, {
+    relationName: "conversationEvaluationResults"
+  })
+}));
+drizzleOrm.relations(
+  datasetRunConversationRelations,
+  ({ one }) => ({
+    datasetRun: one(datasetRun, {
+      fields: [
+        datasetRunConversationRelations.tenantId,
+        datasetRunConversationRelations.projectId,
+        datasetRunConversationRelations.datasetRunId
+      ],
+      references: [datasetRun.tenantId, datasetRun.projectId, datasetRun.id]
+    }),
+    conversation: one(conversations, {
+      fields: [
+        datasetRunConversationRelations.tenantId,
+        datasetRunConversationRelations.projectId,
+        datasetRunConversationRelations.conversationId
+      ],
+      references: [conversations.tenantId, conversations.projectId, conversations.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(),
+  expiresAt: zodOpenapi.z.string().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(),
+  toolPolicies: zodOpenapi.z.record(zodOpenapi.z.string(), zodOpenapi.z.object({ needsApproval: zodOpenapi.z.boolean().optional() })).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(),
+  toolPolicies: zodOpenapi.z.record(zodOpenapi.z.string(), zodOpenapi.z.object({ needsApproval: zodOpenapi.z.boolean().optional() })).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");
+var PrebuiltMCPServerSchema = zodOpenapi.z.object({
+  id: zodOpenapi.z.string().describe("Unique identifier for the MCP server"),
+  name: zodOpenapi.z.string().describe("Display name of the MCP server"),
+  url: zodOpenapi.z.url().describe("URL endpoint for the MCP server"),
+  transport: zodOpenapi.z.enum(MCPTransportType).describe("Transport protocol type"),
+  imageUrl: zodOpenapi.z.url().optional().describe("Logo/icon URL for the MCP server"),
+  isOpen: zodOpenapi.z.boolean().optional().describe("Whether the MCP server is open (doesn't require authentication)"),
+  category: zodOpenapi.z.string().optional().describe("Category of the MCP server (e.g., communication, project_management)"),
+  description: zodOpenapi.z.string().optional().describe("Brief description of what the MCP server does"),
+  thirdPartyConnectAccountUrl: zodOpenapi.z.url().optional().describe("URL to connect to the third party account")
+});
+var MCPCatalogListResponse = zodOpenapi.z.object({
+  data: zodOpenapi.z.array(PrebuiltMCPServerSchema)
+}).openapi("MCPCatalogListResponse");
+var ThirdPartyMCPServerResponse = zodOpenapi.z.object({
+  data: PrebuiltMCPServerSchema.nullable()
+}).openapi("ThirdPartyMCPServerResponse");
+
+// 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.MCPCatalogListResponse = MCPCatalogListResponse;
+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.PrebuiltMCPServerSchema = PrebuiltMCPServerSchema;
+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.ThirdPartyMCPServerResponse = ThirdPartyMCPServerResponse;
+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;