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

package/dist/client-exports.cjs

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