@inkeep/agents-core 0.1.4 → 0.1.6

package/dist/validation/index.cjs

@@ -0,0 +1,1642 @@
+'use strict';
+
+var zodOpenapi = require('@hono/zod-openapi');
+var drizzleZod = require('drizzle-zod');
+var drizzleOrm = require('drizzle-orm');
+var sqliteCore = require('drizzle-orm/sqlite-core');
+
+// src/validation/schemas.ts
+var projects = sqliteCore.sqliteTable(
+  "projects",
+  {
+    tenantId: sqliteCore.text("tenant_id").notNull(),
+    id: sqliteCore.text("id").notNull(),
+    // This IS the project ID
+    name: sqliteCore.text("name").notNull(),
+    description: sqliteCore.text("description").notNull(),
+    // Project-level default model settingsuration that can be inherited by graphs and agents
+    models: sqliteCore.text("models", { mode: "json" }).$type(),
+    // Project-level stopWhen configuration that can be inherited by graphs and agents
+    stopWhen: sqliteCore.text("stop_when", { mode: "json" }).$type(),
+    createdAt: sqliteCore.text("created_at").notNull().default(drizzleOrm.sql`CURRENT_TIMESTAMP`),
+    updatedAt: sqliteCore.text("updated_at").notNull().default(drizzleOrm.sql`CURRENT_TIMESTAMP`)
+  },
+  (table) => [sqliteCore.primaryKey({ columns: [table.tenantId, table.id] })]
+);
+var contextConfigs = sqliteCore.sqliteTable(
+  "context_configs",
+  {
+    tenantId: sqliteCore.text("tenant_id").notNull(),
+    projectId: sqliteCore.text("project_id").notNull(),
+    id: sqliteCore.text("id").notNull(),
+    name: sqliteCore.text("name").notNull(),
+    description: sqliteCore.text("description").notNull(),
+    // Developer-defined Zod schema for validating incoming request context
+    requestContextSchema: sqliteCore.blob("request_context_schema", { mode: "json" }).$type(),
+    // Stores serialized Zod schema
+    // Object mapping template keys to fetch definitions that use request context data
+    contextVariables: sqliteCore.blob("context_variables", { mode: "json" }).$type(),
+    createdAt: sqliteCore.text("created_at").notNull().default(drizzleOrm.sql`CURRENT_TIMESTAMP`),
+    updatedAt: sqliteCore.text("updated_at").notNull().default(drizzleOrm.sql`CURRENT_TIMESTAMP`)
+  },
+  (table) => [sqliteCore.primaryKey({ columns: [table.tenantId, table.projectId, table.id] })]
+);
+var contextCache = sqliteCore.sqliteTable(
+  "context_cache",
+  {
+    tenantId: sqliteCore.text("tenant_id").notNull(),
+    projectId: sqliteCore.text("project_id").notNull(),
+    id: sqliteCore.text("id").notNull(),
+    // Always scoped to conversation for complete data isolation
+    conversationId: sqliteCore.text("conversation_id").notNull(),
+    // Reference to the context config and specific fetch definition
+    contextConfigId: sqliteCore.text("context_config_id").notNull(),
+    contextVariableKey: sqliteCore.text("context_variable_key").notNull(),
+    // Key from contextVariables object
+    // The actual cached context data
+    value: sqliteCore.blob("value", { mode: "json" }).$type().notNull(),
+    // Request hash for cache invalidation based on context changes
+    requestHash: sqliteCore.text("request_hash"),
+    // Hash of request context that triggered this cache
+    // Metadata for monitoring and debugging
+    fetchedAt: sqliteCore.text("fetched_at").notNull(),
+    fetchSource: sqliteCore.text("fetch_source"),
+    // URL or source identifier
+    fetchDurationMs: sqliteCore.integer("fetch_duration_ms"),
+    createdAt: sqliteCore.text("created_at").notNull().default(drizzleOrm.sql`CURRENT_TIMESTAMP`),
+    updatedAt: sqliteCore.text("updated_at").notNull().default(drizzleOrm.sql`CURRENT_TIMESTAMP`)
+  },
+  (table) => [
+    sqliteCore.primaryKey({ columns: [table.tenantId, table.projectId, table.id] }),
+    sqliteCore.index("context_cache_lookup_idx").on(
+      table.conversationId,
+      table.contextConfigId,
+      table.contextVariableKey
+    )
+  ]
+);
+var agents = sqliteCore.sqliteTable(
+  "agents",
+  {
+    tenantId: sqliteCore.text("tenant_id").notNull(),
+    projectId: sqliteCore.text("project_id").notNull(),
+    id: sqliteCore.text("id").notNull(),
+    name: sqliteCore.text("name").notNull(),
+    description: sqliteCore.text("description").notNull(),
+    prompt: sqliteCore.text("prompt").notNull(),
+    conversationHistoryConfig: sqliteCore.text("conversation_history_config", {
+      mode: "json"
+    }).$type(),
+    models: sqliteCore.text("models", { mode: "json" }).$type(),
+    // Agent-level stopWhen configuration (inherited from project)
+    stopWhen: sqliteCore.text("stop_when", { mode: "json" }).$type(),
+    createdAt: sqliteCore.text("created_at").notNull().default(drizzleOrm.sql`CURRENT_TIMESTAMP`),
+    updatedAt: sqliteCore.text("updated_at").notNull().default(drizzleOrm.sql`CURRENT_TIMESTAMP`)
+  },
+  (table) => [
+    sqliteCore.primaryKey({ columns: [table.tenantId, table.projectId, table.id] }),
+    sqliteCore.foreignKey({
+      columns: [table.tenantId, table.projectId],
+      foreignColumns: [projects.tenantId, projects.id],
+      name: "agents_project_fk"
+    })
+  ]
+);
+var agentRelations = sqliteCore.sqliteTable(
+  "agent_relations",
+  {
+    tenantId: sqliteCore.text("tenant_id").notNull(),
+    projectId: sqliteCore.text("project_id").notNull(),
+    id: sqliteCore.text("id").notNull(),
+    graphId: sqliteCore.text("graph_id").notNull(),
+    sourceAgentId: sqliteCore.text("source_agent_id").notNull(),
+    // For internal relationships
+    targetAgentId: sqliteCore.text("target_agent_id"),
+    // For external relationships
+    externalAgentId: sqliteCore.text("external_agent_id"),
+    relationType: sqliteCore.text("relation_type"),
+    // 'transfer' | 'delegate'
+    createdAt: sqliteCore.text("created_at").notNull().default(drizzleOrm.sql`CURRENT_TIMESTAMP`),
+    updatedAt: sqliteCore.text("updated_at").notNull().default(drizzleOrm.sql`CURRENT_TIMESTAMP`)
+  },
+  (table) => [
+    sqliteCore.primaryKey({ columns: [table.tenantId, table.projectId, table.id] }),
+    sqliteCore.foreignKey({
+      columns: [table.tenantId, table.projectId],
+      foreignColumns: [projects.tenantId, projects.id],
+      name: "agent_relations_project_fk"
+    })
+  ]
+);
+var externalAgents = sqliteCore.sqliteTable(
+  "external_agents",
+  {
+    tenantId: sqliteCore.text("tenant_id").notNull(),
+    projectId: sqliteCore.text("project_id").notNull(),
+    id: sqliteCore.text("id").notNull(),
+    name: sqliteCore.text("name").notNull(),
+    description: sqliteCore.text("description").notNull(),
+    baseUrl: sqliteCore.text("base_url").notNull(),
+    // A2A endpoint URL
+    credentialReferenceId: sqliteCore.text("credential_reference_id"),
+    headers: sqliteCore.blob("headers", { mode: "json" }).$type(),
+    createdAt: sqliteCore.text("created_at").notNull().default(drizzleOrm.sql`CURRENT_TIMESTAMP`),
+    updatedAt: sqliteCore.text("updated_at").notNull().default(drizzleOrm.sql`CURRENT_TIMESTAMP`)
+  },
+  (table) => [
+    sqliteCore.primaryKey({ columns: [table.tenantId, table.projectId, table.id] }),
+    sqliteCore.foreignKey({
+      columns: [table.tenantId, table.projectId, table.credentialReferenceId],
+      foreignColumns: [
+        credentialReferences.tenantId,
+        credentialReferences.projectId,
+        credentialReferences.id
+      ],
+      name: "external_agents_credential_reference_fk"
+    }).onDelete("set null")
+  ]
+);
+var agentGraph = sqliteCore.sqliteTable(
+  "agent_graph",
+  {
+    tenantId: sqliteCore.text("tenant_id").notNull(),
+    projectId: sqliteCore.text("project_id").notNull(),
+    id: sqliteCore.text("id").notNull(),
+    name: sqliteCore.text("name").notNull(),
+    description: sqliteCore.text("description"),
+    defaultAgentId: sqliteCore.text("default_agent_id").notNull(),
+    // Reference to shared context configuration for all agents in this graph
+    contextConfigId: sqliteCore.text("context_config_id"),
+    // Graph-level model settingsuration that can be inherited by agents
+    models: sqliteCore.text("models", { mode: "json" }).$type(),
+    // Status updates configuration for intelligent progress summaries
+    statusUpdates: sqliteCore.text("status_updates", { mode: "json" }).$type(),
+    // Graph-level prompt that can be used as additional context for agents
+    graphPrompt: sqliteCore.text("graph_prompt"),
+    // Graph-level stopWhen configuration that can be inherited by agents
+    stopWhen: sqliteCore.text("stop_when", { mode: "json" }).$type(),
+    createdAt: sqliteCore.text("created_at").notNull().default(drizzleOrm.sql`CURRENT_TIMESTAMP`),
+    updatedAt: sqliteCore.text("updated_at").notNull().default(drizzleOrm.sql`CURRENT_TIMESTAMP`)
+  },
+  (table) => [
+    sqliteCore.primaryKey({ columns: [table.tenantId, table.projectId, table.id] }),
+    sqliteCore.foreignKey({
+      columns: [table.tenantId, table.projectId],
+      foreignColumns: [projects.tenantId, projects.id],
+      name: "agent_graph_project_fk"
+    })
+  ]
+);
+var tasks = sqliteCore.sqliteTable(
+  "tasks",
+  {
+    tenantId: sqliteCore.text("tenant_id").notNull(),
+    projectId: sqliteCore.text("project_id").notNull(),
+    id: sqliteCore.text("id").notNull(),
+    contextId: sqliteCore.text("context_id").notNull(),
+    status: sqliteCore.text("status").notNull(),
+    metadata: sqliteCore.blob("metadata", { mode: "json" }).$type(),
+    agentId: sqliteCore.text("agent_id").notNull(),
+    createdAt: sqliteCore.text("created_at").notNull().default(drizzleOrm.sql`CURRENT_TIMESTAMP`),
+    updatedAt: sqliteCore.text("updated_at").notNull().default(drizzleOrm.sql`CURRENT_TIMESTAMP`)
+  },
+  (table) => [sqliteCore.primaryKey({ columns: [table.tenantId, table.projectId, table.id] })]
+);
+var taskRelations = sqliteCore.sqliteTable(
+  "task_relations",
+  {
+    tenantId: sqliteCore.text("tenant_id").notNull(),
+    projectId: sqliteCore.text("project_id").notNull(),
+    id: sqliteCore.text("id").notNull(),
+    parentTaskId: sqliteCore.text("parent_task_id").notNull(),
+    childTaskId: sqliteCore.text("child_task_id").notNull(),
+    relationType: sqliteCore.text("relation_type").default("parent_child"),
+    // Could be extended for other relation types
+    createdAt: sqliteCore.text("created_at").notNull().default(drizzleOrm.sql`CURRENT_TIMESTAMP`),
+    updatedAt: sqliteCore.text("updated_at").notNull().default(drizzleOrm.sql`CURRENT_TIMESTAMP`)
+  },
+  (table) => [sqliteCore.primaryKey({ columns: [table.tenantId, table.projectId, table.id] })]
+);
+var dataComponents = sqliteCore.sqliteTable(
+  "data_components",
+  {
+    tenantId: sqliteCore.text("tenant_id").notNull(),
+    projectId: sqliteCore.text("project_id").notNull(),
+    id: sqliteCore.text("id").notNull(),
+    name: sqliteCore.text("name").notNull(),
+    description: sqliteCore.text("description").notNull(),
+    props: sqliteCore.blob("props", { mode: "json" }).$type(),
+    createdAt: sqliteCore.text("created_at").notNull().default(drizzleOrm.sql`CURRENT_TIMESTAMP`),
+    updatedAt: sqliteCore.text("updated_at").notNull().default(drizzleOrm.sql`CURRENT_TIMESTAMP`)
+  },
+  (table) => [sqliteCore.primaryKey({ columns: [table.tenantId, table.projectId, table.id] })]
+);
+var agentDataComponents = sqliteCore.sqliteTable(
+  "agent_data_components",
+  {
+    tenantId: sqliteCore.text("tenant_id").notNull(),
+    projectId: sqliteCore.text("project_id").notNull(),
+    id: sqliteCore.text("id").notNull(),
+    agentId: sqliteCore.text("agent_id").notNull(),
+    dataComponentId: sqliteCore.text("data_component_id").notNull(),
+    createdAt: sqliteCore.text("created_at").notNull().default(drizzleOrm.sql`CURRENT_TIMESTAMP`)
+  },
+  (table) => [
+    sqliteCore.primaryKey({ columns: [table.tenantId, table.projectId, table.id] }),
+    // Foreign key constraint to agents table
+    sqliteCore.foreignKey({
+      columns: [table.tenantId, table.projectId, table.agentId],
+      foreignColumns: [agents.tenantId, agents.projectId, agents.id],
+      name: "agent_data_components_agent_fk"
+    }).onDelete("cascade"),
+    // Foreign key constraint to data_components table
+    sqliteCore.foreignKey({
+      columns: [table.tenantId, table.projectId, table.dataComponentId],
+      foreignColumns: [dataComponents.tenantId, dataComponents.projectId, dataComponents.id],
+      name: "agent_data_components_data_component_fk"
+    }).onDelete("cascade")
+  ]
+);
+var artifactComponents = sqliteCore.sqliteTable(
+  "artifact_components",
+  {
+    tenantId: sqliteCore.text("tenant_id").notNull(),
+    projectId: sqliteCore.text("project_id").notNull(),
+    id: sqliteCore.text("id").notNull(),
+    name: sqliteCore.text("name").notNull(),
+    description: sqliteCore.text("description").notNull(),
+    summaryProps: sqliteCore.blob("summary_props", { mode: "json" }).$type(),
+    fullProps: sqliteCore.blob("full_props", { mode: "json" }).$type(),
+    createdAt: sqliteCore.text("created_at").notNull().default(drizzleOrm.sql`CURRENT_TIMESTAMP`),
+    updatedAt: sqliteCore.text("updated_at").notNull().default(drizzleOrm.sql`CURRENT_TIMESTAMP`)
+  },
+  (table) => [sqliteCore.primaryKey({ columns: [table.tenantId, table.projectId, table.id] })]
+);
+var agentArtifactComponents = sqliteCore.sqliteTable(
+  "agent_artifact_components",
+  {
+    tenantId: sqliteCore.text("tenant_id").notNull(),
+    projectId: sqliteCore.text("project_id").notNull(),
+    id: sqliteCore.text("id").notNull(),
+    agentId: sqliteCore.text("agent_id").notNull(),
+    artifactComponentId: sqliteCore.text("artifact_component_id").notNull(),
+    createdAt: sqliteCore.text("created_at").notNull().default(drizzleOrm.sql`CURRENT_TIMESTAMP`)
+  },
+  (table) => [
+    sqliteCore.primaryKey({ columns: [table.tenantId, table.projectId, table.id] }),
+    // Foreign key constraint to agents table
+    sqliteCore.foreignKey({
+      columns: [table.tenantId, table.projectId, table.agentId],
+      foreignColumns: [agents.tenantId, agents.projectId, agents.id],
+      name: "agent_artifact_components_agent_fk"
+    }).onDelete("cascade"),
+    // Foreign key constraint to artifact_components table
+    sqliteCore.foreignKey({
+      columns: [table.tenantId, table.projectId, table.artifactComponentId],
+      foreignColumns: [
+        artifactComponents.tenantId,
+        artifactComponents.projectId,
+        artifactComponents.id
+      ],
+      name: "agent_artifact_components_artifact_component_fk"
+    }).onDelete("cascade")
+  ]
+);
+var tools = sqliteCore.sqliteTable(
+  "tools",
+  {
+    tenantId: sqliteCore.text("tenant_id").notNull(),
+    projectId: sqliteCore.text("project_id").notNull(),
+    id: sqliteCore.text("id").notNull(),
+    name: sqliteCore.text("name").notNull(),
+    // Enhanced MCP configuration
+    config: sqliteCore.blob("config", { mode: "json" }).$type().notNull(),
+    credentialReferenceId: sqliteCore.text("credential_reference_id"),
+    headers: sqliteCore.blob("headers", { mode: "json" }).$type(),
+    // Image URL for custom tool icon (supports regular URLs and base64 encoded images)
+    imageUrl: sqliteCore.text("image_url"),
+    // Server capabilities and status
+    capabilities: sqliteCore.blob("capabilities", { mode: "json" }).$type(),
+    // Connection health and monitoring
+    status: sqliteCore.text("status").notNull().default("unknown"),
+    lastHealthCheck: sqliteCore.text("last_health_check"),
+    lastError: sqliteCore.text("last_error"),
+    // Tool discovery cache
+    availableTools: sqliteCore.blob("available_tools", { mode: "json" }).$type(),
+    lastToolsSync: sqliteCore.text("last_tools_sync"),
+    createdAt: sqliteCore.text("created_at").notNull().default(drizzleOrm.sql`CURRENT_TIMESTAMP`),
+    updatedAt: sqliteCore.text("updated_at").notNull().default(drizzleOrm.sql`CURRENT_TIMESTAMP`)
+  },
+  (table) => [sqliteCore.primaryKey({ columns: [table.tenantId, table.projectId, table.id] })]
+);
+var agentToolRelations = sqliteCore.sqliteTable(
+  "agent_tool_relations",
+  {
+    tenantId: sqliteCore.text("tenant_id").notNull(),
+    projectId: sqliteCore.text("project_id").notNull(),
+    id: sqliteCore.text("id").notNull(),
+    agentId: sqliteCore.text("agent_id").notNull(),
+    toolId: sqliteCore.text("tool_id").notNull(),
+    selectedTools: sqliteCore.blob("selected_tools", { mode: "json" }).$type(),
+    createdAt: sqliteCore.text("created_at").notNull().default(drizzleOrm.sql`CURRENT_TIMESTAMP`),
+    updatedAt: sqliteCore.text("updated_at").notNull().default(drizzleOrm.sql`CURRENT_TIMESTAMP`)
+  },
+  (table) => [
+    sqliteCore.primaryKey({ columns: [table.tenantId, table.projectId, table.id] }),
+    // Foreign key constraint to agents table
+    sqliteCore.foreignKey({
+      columns: [table.tenantId, table.projectId, table.agentId],
+      foreignColumns: [agents.tenantId, agents.projectId, agents.id],
+      name: "agent_tool_relations_agent_fk"
+    }).onDelete("cascade"),
+    // Foreign key constraint to tools table
+    sqliteCore.foreignKey({
+      columns: [table.tenantId, table.projectId, table.toolId],
+      foreignColumns: [tools.tenantId, tools.projectId, tools.id],
+      name: "agent_tool_relations_tool_fk"
+    }).onDelete("cascade")
+  ]
+);
+var conversations = sqliteCore.sqliteTable(
+  "conversations",
+  {
+    tenantId: sqliteCore.text("tenant_id").notNull(),
+    projectId: sqliteCore.text("project_id").notNull(),
+    id: sqliteCore.text("id").notNull(),
+    userId: sqliteCore.text("user_id"),
+    activeAgentId: sqliteCore.text("active_agent_id").notNull(),
+    title: sqliteCore.text("title"),
+    lastContextResolution: sqliteCore.text("last_context_resolution"),
+    metadata: sqliteCore.blob("metadata", { mode: "json" }).$type(),
+    createdAt: sqliteCore.text("created_at").notNull().default(drizzleOrm.sql`CURRENT_TIMESTAMP`),
+    updatedAt: sqliteCore.text("updated_at").notNull().default(drizzleOrm.sql`CURRENT_TIMESTAMP`)
+  },
+  (table) => [sqliteCore.primaryKey({ columns: [table.tenantId, table.projectId, table.id] })]
+);
+var messages = sqliteCore.sqliteTable(
+  "messages",
+  {
+    tenantId: sqliteCore.text("tenant_id").notNull(),
+    projectId: sqliteCore.text("project_id").notNull(),
+    id: sqliteCore.text("id").notNull(),
+    conversationId: sqliteCore.text("conversation_id").notNull(),
+    // Role mapping: user, agent, system (unified for both formats)
+    role: sqliteCore.text("role").notNull(),
+    // 'user' | 'agent' | 'system'
+    // Agent sender/recipient tracking (nullable - only populated when relevant)
+    fromAgentId: sqliteCore.text("from_agent_id"),
+    // Populated when message is from an agent
+    toAgentId: sqliteCore.text("to_agent_id"),
+    // Populated when message is directed to a specific agent (e.g., transfers/delegations)
+    // External agent sender tracking
+    fromExternalAgentId: sqliteCore.text("from_external_agent_id"),
+    // Populated when message is directed from an external agent
+    // External agent recipient tracking
+    toExternalAgentId: sqliteCore.text("to_external_agent_id"),
+    // Populated when message is directed to an external agent
+    // Message content stored as JSON to support both formats
+    content: sqliteCore.blob("content", { mode: "json" }).$type().notNull(),
+    // Message classification and filtering
+    visibility: sqliteCore.text("visibility").notNull().default("user-facing"),
+    // 'user-facing' | 'internal' | 'system' | 'external'
+    messageType: sqliteCore.text("message_type").notNull().default("chat"),
+    // 'chat' | 'a2a-request' | 'a2a-response' | 'task-update' | 'tool-call'
+    // Legacy agent association (consider deprecating in favor of fromAgentId/toAgentId)
+    agentId: sqliteCore.text("agent_id"),
+    taskId: sqliteCore.text("task_id"),
+    parentMessageId: sqliteCore.text("parent_message_id"),
+    // Remove self-reference constraint here
+    // A2A specific fields
+    a2aTaskId: sqliteCore.text("a2a_task_id"),
+    // Links to A2A task when relevant
+    a2aSessionId: sqliteCore.text("a2a_session_id"),
+    // A2A session identifier
+    // Metadata for extensions
+    metadata: sqliteCore.blob("metadata", { mode: "json" }).$type(),
+    createdAt: sqliteCore.text("created_at").notNull().default(drizzleOrm.sql`CURRENT_TIMESTAMP`),
+    updatedAt: sqliteCore.text("updated_at").notNull().default(drizzleOrm.sql`CURRENT_TIMESTAMP`)
+  },
+  (table) => [sqliteCore.primaryKey({ columns: [table.tenantId, table.projectId, table.id] })]
+);
+var ledgerArtifacts = sqliteCore.sqliteTable(
+  "ledger_artifacts",
+  {
+    // Primary identifier (maps to `artifactId`)
+    tenantId: sqliteCore.text("tenant_id").notNull(),
+    projectId: sqliteCore.text("project_id").notNull(),
+    id: sqliteCore.text("id").notNull(),
+    // Links
+    taskId: sqliteCore.text("task_id"),
+    contextId: sqliteCore.text("context_id").notNull(),
+    // Core Artifact fields
+    type: sqliteCore.text("type").notNull().default("source"),
+    name: sqliteCore.text("name"),
+    description: sqliteCore.text("description"),
+    parts: sqliteCore.blob("parts", { mode: "json" }).$type(),
+    metadata: sqliteCore.blob("metadata", { mode: "json" }).$type(),
+    // Extra ledger information (not part of the Artifact spec – kept optional)
+    summary: sqliteCore.text("summary"),
+    mime: sqliteCore.blob("mime", { mode: "json" }).$type(),
+    visibility: sqliteCore.text("visibility").default("context"),
+    allowedAgents: sqliteCore.blob("allowed_agents", { mode: "json" }).$type(),
+    derivedFrom: sqliteCore.text("derived_from"),
+    // Timestamps
+    createdAt: sqliteCore.text("created_at").notNull().default(drizzleOrm.sql`CURRENT_TIMESTAMP`),
+    updatedAt: sqliteCore.text("updated_at").notNull().default(drizzleOrm.sql`CURRENT_TIMESTAMP`)
+  },
+  (table) => [sqliteCore.primaryKey({ columns: [table.tenantId, table.projectId, table.id] })]
+);
+var apiKeys = sqliteCore.sqliteTable(
+  "api_keys",
+  {
+    id: sqliteCore.text("id").primaryKey(),
+    tenantId: sqliteCore.text("tenant_id").notNull(),
+    projectId: sqliteCore.text("project_id").notNull(),
+    graphId: sqliteCore.text("graph_id").notNull(),
+    publicId: sqliteCore.text("public_id").notNull().unique(),
+    // Public ID for O(1) lookup (e.g., "abc123def456")
+    keyHash: sqliteCore.text("key_hash").notNull(),
+    // Hashed API key (never store plaintext)
+    keyPrefix: sqliteCore.text("key_prefix").notNull(),
+    // First 8 chars for identification (e.g., "sk_live_abc...")
+    lastUsedAt: sqliteCore.text("last_used_at"),
+    expiresAt: sqliteCore.text("expires_at"),
+    createdAt: sqliteCore.text("created_at").notNull().default(drizzleOrm.sql`CURRENT_TIMESTAMP`),
+    updatedAt: sqliteCore.text("updated_at").notNull().default(drizzleOrm.sql`CURRENT_TIMESTAMP`)
+  },
+  (t) => [
+    sqliteCore.foreignKey({
+      columns: [t.tenantId, t.projectId, t.graphId],
+      foreignColumns: [agentGraph.tenantId, agentGraph.projectId, agentGraph.id],
+      name: "api_keys_graph_fk"
+    }).onDelete("cascade"),
+    sqliteCore.index("api_keys_tenant_graph_idx").on(t.tenantId, t.graphId),
+    sqliteCore.index("api_keys_prefix_idx").on(t.keyPrefix),
+    sqliteCore.index("api_keys_public_id_idx").on(t.publicId)
+  ]
+);
+var credentialReferences = sqliteCore.sqliteTable(
+  "credential_references",
+  {
+    tenantId: sqliteCore.text("tenant_id").notNull(),
+    projectId: sqliteCore.text("project_id").notNull(),
+    id: sqliteCore.text("id").notNull(),
+    type: sqliteCore.text("type").notNull(),
+    // Implementation type: 'keychain', 'nango', 'memory', etc.
+    credentialStoreId: sqliteCore.text("credential_store_id").notNull(),
+    // Maps to framework.getCredentialStore(id)
+    retrievalParams: sqliteCore.blob("retrieval_params", { mode: "json" }).$type(),
+    createdAt: sqliteCore.text("created_at").notNull().default(drizzleOrm.sql`CURRENT_TIMESTAMP`),
+    updatedAt: sqliteCore.text("updated_at").notNull().default(drizzleOrm.sql`CURRENT_TIMESTAMP`)
+  },
+  (t) => [sqliteCore.primaryKey({ columns: [t.tenantId, t.projectId, t.id] })]
+);
+sqliteCore.index("ledger_artifacts_task_id_idx").on(
+  ledgerArtifacts.taskId
+);
+sqliteCore.index("ledger_artifacts_context_id_idx").on(
+  ledgerArtifacts.contextId
+);
+sqliteCore.unique(
+  "ledger_artifacts_task_context_name_unique"
+).on(ledgerArtifacts.taskId, ledgerArtifacts.contextId, ledgerArtifacts.name);
+drizzleOrm.relations(tasks, ({ one, many }) => ({
+  // A task belongs to one project
+  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"
+  }),
+  // A task belongs to one agent
+  agent: one(agents, {
+    fields: [tasks.agentId],
+    references: [agents.id]
+  }),
+  // A task can have many messages associated with it
+  messages: many(messages)
+}));
+drizzleOrm.relations(projects, ({ many }) => ({
+  // A project can have many agents
+  agents: many(agents),
+  // A project can have many agent graphs
+  agentGraphs: many(agentGraph),
+  // A project can have many tools
+  tools: many(tools),
+  // A project can have many context configs
+  contextConfigs: many(contextConfigs),
+  // A project can have many external agents
+  externalAgents: many(externalAgents),
+  // A project can have many conversations
+  conversations: many(conversations),
+  // A project can have many tasks
+  tasks: many(tasks)
+}));
+drizzleOrm.relations(taskRelations, ({ one }) => ({
+  // Each relation has one parent task
+  parentTask: one(tasks, {
+    fields: [taskRelations.parentTaskId],
+    references: [tasks.id],
+    relationName: "parentTask"
+  }),
+  // Each relation has one child task
+  childTask: one(tasks, {
+    fields: [taskRelations.childTaskId],
+    references: [tasks.id],
+    relationName: "childTask"
+  })
+}));
+drizzleOrm.relations(contextConfigs, ({ many, one }) => ({
+  // A context config belongs to one project
+  project: one(projects, {
+    fields: [contextConfigs.tenantId, contextConfigs.projectId],
+    references: [projects.tenantId, projects.id]
+  }),
+  // A context config can be used by many agent graphs
+  graphs: many(agentGraph),
+  // A context config can have many cached entries
+  cache: many(contextCache)
+}));
+drizzleOrm.relations(contextCache, ({ one }) => ({
+  // Each cache entry belongs to one context config
+  contextConfig: one(contextConfigs, {
+    fields: [contextCache.contextConfigId],
+    references: [contextConfigs.id]
+  })
+}));
+drizzleOrm.relations(agents, ({ many, one }) => ({
+  // A context config belongs to one project
+  project: one(projects, {
+    fields: [agents.tenantId, agents.projectId],
+    references: [projects.tenantId, projects.id]
+  }),
+  // An agent can have many tasks
+  tasks: many(tasks),
+  // An agent can be the default agent for many graphs
+  defaultForGraphs: many(agentGraph),
+  // Agent relation tracking
+  sourceRelations: many(agentRelations, {
+    relationName: "sourceRelations"
+  }),
+  targetRelations: many(agentRelations, {
+    relationName: "targetRelations"
+  }),
+  // Message tracking relations
+  sentMessages: many(messages, {
+    relationName: "sentMessages"
+  }),
+  receivedMessages: many(messages, {
+    relationName: "receivedMessages"
+  }),
+  // Legacy message association (consider deprecating)
+  associatedMessages: many(messages, {
+    relationName: "associatedAgent"
+  }),
+  toolRelations: many(agentToolRelations)
+}));
+drizzleOrm.relations(agentGraph, ({ one }) => ({
+  // An agent graph belongs to one project
+  project: one(projects, {
+    fields: [agentGraph.tenantId, agentGraph.projectId],
+    references: [projects.tenantId, projects.id]
+  }),
+  // An agent graph belongs to one default agent
+  defaultAgent: one(agents, {
+    fields: [agentGraph.defaultAgentId],
+    references: [agents.id]
+  }),
+  // An agent graph can reference one context config
+  contextConfig: one(contextConfigs, {
+    fields: [agentGraph.contextConfigId],
+    references: [contextConfigs.id]
+  })
+}));
+drizzleOrm.relations(externalAgents, ({ one, many }) => ({
+  // An external agent belongs to one project
+  project: one(projects, {
+    fields: [externalAgents.tenantId, externalAgents.projectId],
+    references: [projects.tenantId, projects.id]
+  }),
+  // An external agent can be referenced by many agent relations
+  agentRelations: many(agentRelations),
+  // An external agent may have one credential reference
+  credentialReference: one(credentialReferences, {
+    fields: [externalAgents.credentialReferenceId],
+    references: [credentialReferences.id]
+  })
+}));
+drizzleOrm.relations(apiKeys, ({ one }) => ({
+  // An API key belongs to one project
+  project: one(projects, {
+    fields: [apiKeys.tenantId, apiKeys.projectId],
+    references: [projects.tenantId, projects.id]
+  }),
+  // An API key belongs to one tenant and graph
+  graph: one(agentGraph, {
+    fields: [apiKeys.graphId],
+    references: [agentGraph.id]
+  })
+}));
+drizzleOrm.relations(agentToolRelations, ({ one }) => ({
+  // An agent-tool relation belongs to one agent
+  agent: one(agents, {
+    fields: [agentToolRelations.agentId],
+    references: [agents.id]
+  }),
+  // An agent-tool relation belongs to one tool
+  tool: one(tools, {
+    fields: [agentToolRelations.toolId],
+    references: [tools.id]
+  })
+}));
+drizzleOrm.relations(credentialReferences, ({ many }) => ({
+  tools: many(tools)
+}));
+drizzleOrm.relations(tools, ({ one, many }) => ({
+  // A tool belongs to one project
+  project: one(projects, {
+    fields: [tools.tenantId, tools.projectId],
+    references: [projects.tenantId, projects.id]
+  }),
+  // A tool can be used by many agents through agent-tool relations
+  agentRelations: many(agentToolRelations),
+  // A tool may have one credential reference
+  credentialReference: one(credentialReferences, {
+    fields: [tools.credentialReferenceId],
+    references: [credentialReferences.id]
+  })
+}));
+drizzleOrm.relations(conversations, ({ one, many }) => ({
+  // A conversation belongs to one project
+  project: one(projects, {
+    fields: [conversations.tenantId, conversations.projectId],
+    references: [projects.tenantId, projects.id]
+  }),
+  // A conversation has many messages
+  messages: many(messages),
+  // A conversation has one active agent
+  activeAgent: one(agents, {
+    fields: [conversations.activeAgentId],
+    references: [agents.id]
+  })
+}));
+drizzleOrm.relations(messages, ({ one, many }) => ({
+  // A message belongs to one conversation
+  conversation: one(conversations, {
+    fields: [messages.conversationId],
+    references: [conversations.id]
+  }),
+  // Legacy agent association (consider deprecating)
+  agent: one(agents, {
+    fields: [messages.agentId],
+    references: [agents.id],
+    relationName: "associatedAgent"
+  }),
+  // Sender tracking relations
+  fromAgent: one(agents, {
+    fields: [messages.fromAgentId],
+    references: [agents.id],
+    relationName: "sentMessages"
+  }),
+  // Recipient tracking relations
+  toAgent: one(agents, {
+    fields: [messages.toAgentId],
+    references: [agents.id],
+    relationName: "receivedMessages"
+  }),
+  // External agent sender tracking relations
+  fromExternalAgent: one(externalAgents, {
+    fields: [messages.fromExternalAgentId],
+    references: [externalAgents.id],
+    relationName: "receivedExternalMessages"
+  }),
+  // External agent recipient tracking relations
+  toExternalAgent: one(externalAgents, {
+    fields: [messages.toExternalAgentId],
+    references: [externalAgents.id],
+    relationName: "sentExternalMessages"
+  }),
+  // A message may be associated with a task
+  task: one(tasks, {
+    fields: [messages.taskId],
+    references: [tasks.id]
+  }),
+  // A message may have a parent message (for threading)
+  parentMessage: one(messages, {
+    fields: [messages.parentMessageId],
+    references: [messages.id],
+    relationName: "parentChild"
+  }),
+  // A message may have child messages
+  childMessages: many(messages, {
+    relationName: "parentChild"
+  })
+}));
+drizzleOrm.relations(artifactComponents, ({ many }) => ({
+  // An artifact component can be associated with many agents
+  agentRelations: many(agentArtifactComponents)
+}));
+drizzleOrm.relations(agentArtifactComponents, ({ one }) => ({
+  // An agent-artifact component relation belongs to one agent
+  agent: one(agents, {
+    fields: [agentArtifactComponents.agentId],
+    references: [agents.id]
+  }),
+  // An agent-artifact component relation belongs to one artifact component
+  artifactComponent: one(artifactComponents, {
+    fields: [agentArtifactComponents.artifactComponentId],
+    references: [artifactComponents.id]
+  })
+}));
+drizzleOrm.relations(agentRelations, ({ one }) => ({
+  // An agent relation belongs to one graph
+  graph: one(agentGraph, {
+    fields: [agentRelations.graphId],
+    references: [agentGraph.id]
+  }),
+  // An agent relation has one source agent
+  sourceAgent: one(agents, {
+    fields: [agentRelations.sourceAgentId],
+    references: [agents.id],
+    relationName: "sourceRelations"
+  }),
+  // An agent relation may have one target agent (for internal relations)
+  targetAgent: one(agents, {
+    fields: [agentRelations.targetAgentId],
+    references: [agents.id],
+    relationName: "targetRelations"
+  }),
+  // An agent relation may have one external agent (for external relations)
+  externalAgent: one(externalAgents, {
+    fields: [agentRelations.externalAgentId],
+    references: [externalAgents.id]
+  })
+}));
+
+// src/types/utility.ts
+var TOOL_STATUS_VALUES = [
+  "healthy",
+  "unhealthy",
+  "unknown",
+  "disabled",
+  "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"
+};
+
+// src/validation/schemas.ts
+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).regex(URL_SAFE_ID_PATTERN, {
+  message: "ID must contain only letters, numbers, hyphens, underscores, and dots"
+}).openapi({
+  description: "Resource identifier",
+  example: "resource_789"
+});
+var ModelSettingsSchema = zodOpenapi.z.object({
+  model: zodOpenapi.z.string().optional(),
+  providerOptions: zodOpenapi.z.record(zodOpenapi.z.string(), zodOpenapi.z.unknown()).optional()
+});
+var ModelSchema = zodOpenapi.z.object({
+  base: ModelSettingsSchema.optional(),
+  structuredOutput: ModelSettingsSchema.optional(),
+  summarizer: ModelSettingsSchema.optional()
+});
+var ProjectModelSchema = zodOpenapi.z.object({
+  base: ModelSettingsSchema,
+  structuredOutput: ModelSettingsSchema.optional(),
+  summarizer: ModelSettingsSchema.optional()
+});
+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 AgentSelectSchema = drizzleZod.createSelectSchema(agents);
+var AgentInsertSchema = drizzleZod.createInsertSchema(agents).extend({
+  id: resourceIdSchema,
+  models: ModelSchema.optional()
+});
+var AgentUpdateSchema = AgentInsertSchema.partial();
+var AgentApiSelectSchema = createApiSchema(AgentSelectSchema);
+var AgentApiInsertSchema = createApiInsertSchema(AgentInsertSchema);
+var AgentApiUpdateSchema = createApiUpdateSchema(AgentUpdateSchema);
+var AgentRelationSelectSchema = drizzleZod.createSelectSchema(agentRelations);
+var AgentRelationInsertSchema = drizzleZod.createInsertSchema(agentRelations).extend({
+  id: resourceIdSchema,
+  graphId: resourceIdSchema,
+  sourceAgentId: resourceIdSchema,
+  targetAgentId: resourceIdSchema.optional(),
+  externalAgentId: resourceIdSchema.optional()
+});
+var AgentRelationUpdateSchema = AgentRelationInsertSchema.partial();
+var AgentRelationApiSelectSchema = createApiSchema(AgentRelationSelectSchema);
+var AgentRelationApiInsertSchema = createApiInsertSchema(AgentRelationInsertSchema).extend({
+  relationType: zodOpenapi.z.enum(VALID_RELATION_TYPES)
+}).refine(
+  (data) => {
+    const hasTarget = data.targetAgentId != null;
+    const hasExternal = data.externalAgentId != null;
+    return hasTarget !== hasExternal;
+  },
+  {
+    message: "Must specify exactly one of targetAgentId or externalAgentId",
+    path: ["targetAgentId", "externalAgentId"]
+  }
+);
+var AgentRelationApiUpdateSchema = createApiUpdateSchema(AgentRelationUpdateSchema).extend({
+  relationType: zodOpenapi.z.enum(VALID_RELATION_TYPES).optional()
+}).refine(
+  (data) => {
+    const hasTarget = data.targetAgentId != null;
+    const hasExternal = data.externalAgentId != null;
+    if (!hasTarget && !hasExternal) {
+      return true;
+    }
+    return hasTarget !== hasExternal;
+  },
+  {
+    message: "Must specify exactly one of targetAgentId or externalAgentId when updating agent relationships",
+    path: ["targetAgentId", "externalAgentId"]
+  }
+);
+var AgentRelationQuerySchema = zodOpenapi.z.object({
+  sourceAgentId: zodOpenapi.z.string().optional(),
+  targetAgentId: zodOpenapi.z.string().optional(),
+  externalAgentId: zodOpenapi.z.string().optional()
+});
+var ExternalAgentRelationInsertSchema = drizzleZod.createInsertSchema(agentRelations).extend({
+  id: resourceIdSchema,
+  graphId: resourceIdSchema,
+  sourceAgentId: resourceIdSchema,
+  externalAgentId: resourceIdSchema
+});
+var ExternalAgentRelationApiInsertSchema = createApiInsertSchema(
+  ExternalAgentRelationInsertSchema
+);
+var AgentGraphSelectSchema = drizzleZod.createSelectSchema(agentGraph);
+var AgentGraphInsertSchema = drizzleZod.createInsertSchema(agentGraph).extend({
+  id: resourceIdSchema
+});
+var AgentGraphUpdateSchema = AgentGraphInsertSchema.partial();
+var AgentGraphApiSelectSchema = createApiSchema(AgentGraphSelectSchema);
+var AgentGraphApiInsertSchema = createApiInsertSchema(AgentGraphInsertSchema).extend({
+  id: resourceIdSchema.optional()
+});
+var AgentGraphApiUpdateSchema = createApiUpdateSchema(AgentGraphUpdateSchema);
+var TaskSelectSchema = drizzleZod.createSelectSchema(tasks);
+var TaskInsertSchema = drizzleZod.createInsertSchema(tasks).extend({
+  id: resourceIdSchema,
+  conversationId: resourceIdSchema.optional()
+});
+var TaskUpdateSchema = TaskInsertSchema.partial();
+var TaskApiSelectSchema = createApiSchema(TaskSelectSchema);
+var TaskApiInsertSchema = createApiInsertSchema(TaskInsertSchema);
+var TaskApiUpdateSchema = createApiUpdateSchema(TaskUpdateSchema);
+var TaskRelationSelectSchema = drizzleZod.createSelectSchema(taskRelations);
+var TaskRelationInsertSchema = drizzleZod.createInsertSchema(taskRelations).extend({
+  id: resourceIdSchema,
+  parentTaskId: resourceIdSchema,
+  childTaskId: resourceIdSchema
+});
+var TaskRelationUpdateSchema = TaskRelationInsertSchema.partial();
+var TaskRelationApiSelectSchema = createApiSchema(TaskRelationSelectSchema);
+var TaskRelationApiInsertSchema = createApiInsertSchema(TaskRelationInsertSchema);
+var TaskRelationApiUpdateSchema = createApiUpdateSchema(TaskRelationUpdateSchema);
+var imageUrlSchema = zodOpenapi.z.string().optional().refine(
+  (url) => {
+    if (!url) return true;
+    if (url.startsWith("data:image/")) {
+      const base64Part = url.split(",")[1];
+      if (!base64Part) return false;
+      return base64Part.length < 14e5;
+    }
+    try {
+      const parsed = new URL(url);
+      return parsed.protocol === "http:" || parsed.protocol === "https:";
+    } catch {
+      return false;
+    }
+  },
+  {
+    message: "Image URL must be a valid HTTP(S) URL or a base64 data URL (max 1MB)"
+  }
+);
+var McpTransportConfigSchema = zodOpenapi.z.object({
+  type: zodOpenapi.z.enum(MCPTransportType),
+  requestInit: zodOpenapi.z.record(zodOpenapi.z.string(), zodOpenapi.z.unknown()).optional(),
+  eventSourceInit: zodOpenapi.z.record(zodOpenapi.z.string(), zodOpenapi.z.unknown()).optional(),
+  reconnectionOptions: zodOpenapi.z.custom().optional(),
+  sessionId: zodOpenapi.z.string().optional()
+});
+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 = drizzleZod.createSelectSchema(tools);
+var ToolInsertSchema = drizzleZod.createInsertSchema(tools).extend({
+  id: resourceIdSchema,
+  imageUrl: imageUrlSchema
+});
+var ConversationSelectSchema = drizzleZod.createSelectSchema(conversations);
+var ConversationInsertSchema = drizzleZod.createInsertSchema(conversations).extend({
+  id: resourceIdSchema,
+  contextConfigId: resourceIdSchema.optional()
+});
+var ConversationUpdateSchema = ConversationInsertSchema.partial();
+var ConversationApiSelectSchema = createApiSchema(ConversationSelectSchema);
+var ConversationApiInsertSchema = createApiInsertSchema(ConversationInsertSchema);
+var ConversationApiUpdateSchema = createApiUpdateSchema(ConversationUpdateSchema);
+var MessageSelectSchema = drizzleZod.createSelectSchema(messages);
+var MessageInsertSchema = drizzleZod.createInsertSchema(messages).extend({
+  id: resourceIdSchema,
+  conversationId: resourceIdSchema,
+  taskId: resourceIdSchema.optional()
+});
+var MessageUpdateSchema = MessageInsertSchema.partial();
+var MessageApiSelectSchema = createApiSchema(MessageSelectSchema);
+var MessageApiInsertSchema = createApiInsertSchema(MessageInsertSchema);
+var MessageApiUpdateSchema = createApiUpdateSchema(MessageUpdateSchema);
+var ContextCacheSelectSchema = drizzleZod.createSelectSchema(contextCache);
+var ContextCacheInsertSchema = drizzleZod.createInsertSchema(contextCache);
+var ContextCacheUpdateSchema = ContextCacheInsertSchema.partial();
+var ContextCacheApiSelectSchema = createApiSchema(ContextCacheSelectSchema);
+var ContextCacheApiInsertSchema = createApiInsertSchema(ContextCacheInsertSchema);
+var ContextCacheApiUpdateSchema = createApiUpdateSchema(ContextCacheUpdateSchema);
+var DataComponentSelectSchema = drizzleZod.createSelectSchema(dataComponents);
+var DataComponentInsertSchema = drizzleZod.createInsertSchema(dataComponents).extend({
+  id: resourceIdSchema
+});
+var DataComponentBaseSchema = DataComponentInsertSchema.omit({
+  createdAt: true,
+  updatedAt: true
+});
+var DataComponentUpdateSchema = DataComponentInsertSchema.partial();
+var DataComponentApiSelectSchema = createApiSchema(DataComponentSelectSchema);
+var DataComponentApiInsertSchema = createApiInsertSchema(DataComponentInsertSchema);
+var DataComponentApiUpdateSchema = createApiUpdateSchema(DataComponentUpdateSchema);
+var AgentDataComponentSelectSchema = drizzleZod.createSelectSchema(agentDataComponents);
+var AgentDataComponentInsertSchema = drizzleZod.createInsertSchema(agentDataComponents);
+var AgentDataComponentUpdateSchema = AgentDataComponentInsertSchema.partial();
+var AgentDataComponentApiSelectSchema = createApiSchema(AgentDataComponentSelectSchema);
+var AgentDataComponentApiInsertSchema = createApiInsertSchema(
+  AgentDataComponentInsertSchema
+);
+var AgentDataComponentApiUpdateSchema = createApiUpdateSchema(
+  AgentDataComponentUpdateSchema
+);
+var ArtifactComponentSelectSchema = drizzleZod.createSelectSchema(artifactComponents);
+var ArtifactComponentInsertSchema = drizzleZod.createInsertSchema(artifactComponents).extend({
+  id: resourceIdSchema
+});
+var ArtifactComponentUpdateSchema = ArtifactComponentInsertSchema.partial();
+var ArtifactComponentApiSelectSchema = createApiSchema(ArtifactComponentSelectSchema);
+var ArtifactComponentApiInsertSchema = ArtifactComponentInsertSchema.omit({
+  tenantId: true,
+  projectId: true,
+  createdAt: true,
+  updatedAt: true
+}).extend({
+  id: resourceIdSchema.optional()
+});
+var ArtifactComponentApiUpdateSchema = createApiUpdateSchema(
+  ArtifactComponentUpdateSchema
+);
+var AgentArtifactComponentSelectSchema = drizzleZod.createSelectSchema(agentArtifactComponents);
+var AgentArtifactComponentInsertSchema = drizzleZod.createInsertSchema(
+  agentArtifactComponents
+).extend({
+  id: resourceIdSchema,
+  agentId: resourceIdSchema,
+  artifactComponentId: resourceIdSchema
+});
+var AgentArtifactComponentUpdateSchema = AgentArtifactComponentInsertSchema.partial();
+var AgentArtifactComponentApiSelectSchema = createApiSchema(
+  AgentArtifactComponentSelectSchema
+);
+var AgentArtifactComponentApiInsertSchema = AgentArtifactComponentInsertSchema.omit({
+  tenantId: true,
+  projectId: true,
+  id: true,
+  createdAt: true
+});
+var AgentArtifactComponentApiUpdateSchema = createApiUpdateSchema(
+  AgentArtifactComponentUpdateSchema
+);
+var ExternalAgentSelectSchema = drizzleZod.createSelectSchema(externalAgents).extend({
+  credentialReferenceId: zodOpenapi.z.string().nullable().optional(),
+  headers: zodOpenapi.z.record(zodOpenapi.z.string(), zodOpenapi.z.string()).nullable().optional()
+});
+var ExternalAgentInsertSchema = drizzleZod.createInsertSchema(externalAgents).extend({
+  id: resourceIdSchema
+});
+var ExternalAgentUpdateSchema = ExternalAgentInsertSchema.partial();
+var ExternalAgentApiSelectSchema = createApiSchema(ExternalAgentSelectSchema);
+var ExternalAgentApiInsertSchema = createApiInsertSchema(ExternalAgentInsertSchema);
+var ExternalAgentApiUpdateSchema = createApiUpdateSchema(ExternalAgentUpdateSchema);
+var AllAgentSchema = zodOpenapi.z.discriminatedUnion("type", [
+  AgentApiSelectSchema.extend({ type: zodOpenapi.z.literal("internal") }),
+  ExternalAgentApiSelectSchema.extend({ type: zodOpenapi.z.literal("external") })
+]);
+var ApiKeySelectSchema = drizzleZod.createSelectSchema(apiKeys);
+var ApiKeyInsertSchema = drizzleZod.createInsertSchema(apiKeys).extend({
+  id: resourceIdSchema,
+  graphId: 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
+});
+var ApiKeyApiCreationResponseSchema = zodOpenapi.z.object({
+  data: zodOpenapi.z.object({
+    apiKey: ApiKeyApiSelectSchema,
+    key: zodOpenapi.z.string().describe("The full API key (shown only once)")
+  })
+});
+var ApiKeyApiInsertSchema = ApiKeyInsertSchema.omit({
+  tenantId: true,
+  projectId: true,
+  id: true,
+  // Auto-generated
+  publicId: true,
+  // Auto-generated
+  keyHash: true,
+  // Auto-generated
+  keyPrefix: true,
+  // Auto-generated
+  lastUsedAt: true
+  // Not set on creation
+});
+var ApiKeyApiUpdateSchema = ApiKeyUpdateSchema;
+var CredentialReferenceSelectSchema = zodOpenapi.z.object({
+  id: zodOpenapi.z.string(),
+  tenantId: zodOpenapi.z.string(),
+  projectId: 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 = zodOpenapi.z.object({
+  id: resourceIdSchema,
+  tenantId: zodOpenapi.z.string(),
+  projectId: zodOpenapi.z.string(),
+  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)
+});
+var CredentialReferenceApiInsertSchema = createApiInsertSchema(
+  CredentialReferenceInsertSchema
+).extend({
+  type: zodOpenapi.z.enum(CredentialStoreType)
+});
+var CredentialReferenceApiUpdateSchema = createApiUpdateSchema(
+  CredentialReferenceUpdateSchema
+).extend({
+  type: zodOpenapi.z.enum(CredentialStoreType).optional()
+});
+var McpToolSchema = ToolInsertSchema.extend({
+  imageUrl: imageUrlSchema,
+  status: ToolStatusSchema.default("unknown"),
+  lastHealthCheck: zodOpenapi.z.date().optional(),
+  lastToolsSync: zodOpenapi.z.date().optional(),
+  version: zodOpenapi.z.string().optional(),
+  createdAt: zodOpenapi.z.date(),
+  updatedAt: zodOpenapi.z.date()
+});
+var MCPToolConfigSchema = McpToolSchema.omit({
+  config: true,
+  tenantId: true,
+  projectId: true,
+  status: true,
+  lastHealthCheck: true,
+  lastToolsSync: 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);
+var ToolApiInsertSchema = createApiInsertSchema(ToolInsertSchema);
+var ToolApiUpdateSchema = createApiUpdateSchema(ToolUpdateSchema);
+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(1e4).optional()
+});
+var FetchDefinitionSchema = zodOpenapi.z.object({
+  id: zodOpenapi.z.string().min(1, "Fetch definition ID is required"),
+  name: zodOpenapi.z.string().optional(),
+  trigger: zodOpenapi.z.enum(["initialization", "invocation"]),
+  fetchConfig: FetchConfigSchema,
+  responseSchema: zodOpenapi.z.any().optional(),
+  // JSON Schema for validating HTTP response
+  defaultValue: zodOpenapi.z.unknown().optional(),
+  credential: CredentialReferenceApiInsertSchema.optional()
+});
+var ContextConfigSelectSchema = drizzleZod.createSelectSchema(contextConfigs).extend({
+  requestContextSchema: zodOpenapi.z.unknown().optional()
+});
+var ContextConfigInsertSchema = drizzleZod.createInsertSchema(contextConfigs).extend({
+  id: resourceIdSchema,
+  requestContextSchema: zodOpenapi.z.unknown().optional()
+}).omit({
+  createdAt: true,
+  updatedAt: true
+});
+var ContextConfigUpdateSchema = ContextConfigInsertSchema.partial();
+var ContextConfigApiSelectSchema = createApiSchema(ContextConfigSelectSchema);
+var ContextConfigApiInsertSchema = createApiInsertSchema(ContextConfigInsertSchema);
+var ContextConfigApiUpdateSchema = createApiUpdateSchema(ContextConfigUpdateSchema);
+var AgentToolRelationSelectSchema = drizzleZod.createSelectSchema(agentToolRelations);
+var AgentToolRelationInsertSchema = drizzleZod.createInsertSchema(agentToolRelations).extend({
+  id: resourceIdSchema,
+  agentId: resourceIdSchema,
+  toolId: resourceIdSchema,
+  selectedTools: zodOpenapi.z.array(zodOpenapi.z.string()).nullish()
+});
+var AgentToolRelationUpdateSchema = AgentToolRelationInsertSchema.partial();
+var AgentToolRelationApiSelectSchema = createApiSchema(AgentToolRelationSelectSchema);
+var AgentToolRelationApiInsertSchema = createApiInsertSchema(
+  AgentToolRelationInsertSchema
+);
+var AgentToolRelationApiUpdateSchema = createApiUpdateSchema(
+  AgentToolRelationUpdateSchema
+);
+var LedgerArtifactSelectSchema = drizzleZod.createSelectSchema(ledgerArtifacts);
+var LedgerArtifactInsertSchema = drizzleZod.createInsertSchema(ledgerArtifacts);
+var LedgerArtifactUpdateSchema = LedgerArtifactInsertSchema.partial();
+var LedgerArtifactApiSelectSchema = createApiSchema(LedgerArtifactSelectSchema);
+var LedgerArtifactApiInsertSchema = createApiInsertSchema(LedgerArtifactInsertSchema);
+var LedgerArtifactApiUpdateSchema = createApiUpdateSchema(LedgerArtifactUpdateSchema);
+var StatusComponentSchema = zodOpenapi.z.object({
+  type: zodOpenapi.z.string(),
+  description: zodOpenapi.z.string().optional(),
+  detailsSchema: zodOpenapi.z.object({
+    type: zodOpenapi.z.literal("object"),
+    properties: zodOpenapi.z.record(zodOpenapi.z.string(), zodOpenapi.z.any()),
+    required: zodOpenapi.z.array(zodOpenapi.z.string()).optional()
+  }).optional()
+});
+var StatusUpdateSchema = zodOpenapi.z.object({
+  enabled: zodOpenapi.z.boolean().optional(),
+  numEvents: zodOpenapi.z.number().min(1).max(100).optional(),
+  timeInSeconds: zodOpenapi.z.number().min(1).max(600).optional(),
+  prompt: zodOpenapi.z.string().max(2e3, "Custom prompt cannot exceed 2000 characters").optional(),
+  statusComponents: zodOpenapi.z.array(StatusComponentSchema).optional()
+});
+var FullGraphAgentInsertSchema = AgentApiInsertSchema.extend({
+  tools: zodOpenapi.z.array(zodOpenapi.z.string()),
+  selectedTools: zodOpenapi.z.record(zodOpenapi.z.string(), zodOpenapi.z.array(zodOpenapi.z.string())).optional(),
+  dataComponents: zodOpenapi.z.array(zodOpenapi.z.string()).optional(),
+  artifactComponents: zodOpenapi.z.array(zodOpenapi.z.string()).optional(),
+  canTransferTo: zodOpenapi.z.array(zodOpenapi.z.string()).optional(),
+  canDelegateTo: zodOpenapi.z.array(zodOpenapi.z.string()).optional()
+});
+var FullGraphDefinitionSchema = AgentGraphApiInsertSchema.extend({
+  agents: zodOpenapi.z.record(zodOpenapi.z.string(), zodOpenapi.z.union([FullGraphAgentInsertSchema, ExternalAgentApiInsertSchema])),
+  tools: zodOpenapi.z.record(zodOpenapi.z.string(), ToolApiInsertSchema),
+  credentialReferences: zodOpenapi.z.array(CredentialReferenceApiInsertSchema).optional(),
+  dataComponents: zodOpenapi.z.record(zodOpenapi.z.string(), DataComponentApiInsertSchema).optional(),
+  artifactComponents: zodOpenapi.z.record(zodOpenapi.z.string(), ArtifactComponentApiInsertSchema).optional(),
+  contextConfig: zodOpenapi.z.optional(ContextConfigApiInsertSchema),
+  statusUpdates: zodOpenapi.z.optional(StatusUpdateSchema),
+  models: ModelSchema.optional(),
+  stopWhen: zodOpenapi.z.object({
+    transferCountIs: zodOpenapi.z.number().min(1).max(100).optional()
+  }).optional(),
+  graphPrompt: zodOpenapi.z.string().max(5e3, "Graph prompt cannot exceed 5000 characters").optional()
+});
+var PaginationSchema = zodOpenapi.z.object({
+  page: zodOpenapi.z.coerce.number().min(1).default(1),
+  limit: zodOpenapi.z.coerce.number().min(1).max(100).default(10),
+  total: zodOpenapi.z.number(),
+  pages: zodOpenapi.z.number()
+});
+var ListResponseSchema = (itemSchema) => zodOpenapi.z.object({
+  data: zodOpenapi.z.array(itemSchema),
+  pagination: PaginationSchema
+});
+var SingleResponseSchema = (itemSchema) => zodOpenapi.z.object({
+  data: itemSchema
+});
+var ErrorResponseSchema = zodOpenapi.z.object({
+  error: zodOpenapi.z.string(),
+  message: zodOpenapi.z.string().optional(),
+  details: zodOpenapi.z.unknown().optional()
+});
+var ExistsResponseSchema = zodOpenapi.z.object({
+  exists: zodOpenapi.z.boolean()
+});
+var RemovedResponseSchema = zodOpenapi.z.object({
+  message: zodOpenapi.z.string(),
+  removed: zodOpenapi.z.boolean()
+});
+var ProjectSelectSchema = drizzleZod.createSelectSchema(projects);
+var ProjectInsertSchema = drizzleZod.createInsertSchema(projects).extend({
+  models: ProjectModelSchema.optional()
+}).omit({
+  createdAt: true,
+  updatedAt: true
+});
+var ProjectUpdateSchema = ProjectInsertSchema.partial();
+var ProjectApiSelectSchema = ProjectSelectSchema.omit({ tenantId: true });
+var ProjectApiInsertSchema = ProjectInsertSchema.omit({ tenantId: true });
+var ProjectApiUpdateSchema = ProjectUpdateSchema.omit({ tenantId: true });
+var HeadersScopeSchema = zodOpenapi.z.object({
+  "x-inkeep-tenant-id": zodOpenapi.z.string().optional().openapi({
+    description: "Tenant identifier",
+    example: "tenant_123"
+  }),
+  "x-inkeep-project-id": zodOpenapi.z.string().optional().openapi({
+    description: "Project identifier",
+    example: "project_456"
+  }),
+  "x-inkeep-graph-id": zodOpenapi.z.string().optional().openapi({
+    description: "Graph identifier",
+    example: "graph_789"
+  })
+});
+var TenantParamsSchema = zodOpenapi.z.object({
+  tenantId: zodOpenapi.z.string().openapi({
+    description: "Tenant identifier",
+    example: "tenant_123"
+  })
+}).openapi("TenantParams");
+var TenantProjectParamsSchema = zodOpenapi.z.object({
+  tenantId: zodOpenapi.z.string().openapi({
+    description: "Tenant identifier",
+    example: "tenant_123"
+  }),
+  projectId: zodOpenapi.z.string().openapi({
+    description: "Project identifier",
+    example: "project_456"
+  })
+}).openapi("TenantProjectParams");
+var TenantProjectIdParamsSchema = zodOpenapi.z.object({
+  tenantId: zodOpenapi.z.string().openapi({
+    description: "Tenant identifier",
+    example: "tenant_123"
+  }),
+  projectId: zodOpenapi.z.string().openapi({
+    description: "Project identifier",
+    example: "project_456"
+  }),
+  id: resourceIdSchema
+}).openapi("TenantProjectIdParams");
+var TenantIdParamsSchema = zodOpenapi.z.object({
+  tenantId: zodOpenapi.z.string().openapi({
+    description: "Tenant identifier",
+    example: "tenant_123"
+  }),
+  id: resourceIdSchema
+}).openapi("TenantIdParams");
+var IdParamsSchema = zodOpenapi.z.object({
+  id: resourceIdSchema
+}).openapi("IdParams");
+var PaginationQueryParamsSchema = zodOpenapi.z.object({
+  page: zodOpenapi.z.coerce.number().min(1).default(1),
+  limit: zodOpenapi.z.coerce.number().min(1).max(100).default(10)
+});
+
+// src/validation/graphFull.ts
+function isInternalAgent(agent) {
+  return "prompt" in agent;
+}
+function isExternalAgent(agent) {
+  return "baseUrl" in agent;
+}
+function validateAndTypeGraphData(data) {
+  return FullGraphDefinitionSchema.parse(data);
+}
+function validateToolReferences(graphData) {
+  const errors = [];
+  const availableToolIds = new Set(Object.keys(graphData.tools));
+  for (const [agentId, agentData] of Object.entries(graphData.agents)) {
+    if (isInternalAgent(agentData) && agentData.tools && Array.isArray(agentData.tools)) {
+      for (const toolId of agentData.tools) {
+        if (!availableToolIds.has(toolId)) {
+          errors.push(`Agent '${agentId}' references non-existent tool '${toolId}'`);
+        }
+      }
+    }
+  }
+  if (errors.length > 0) {
+    throw new Error(`Tool reference validation failed:
+${errors.join("\n")}`);
+  }
+}
+function validateDataComponentReferences(graphData) {
+  const errors = [];
+  const availableDataComponentIds = new Set(Object.keys(graphData.dataComponents || {}));
+  for (const [agentId, agentData] of Object.entries(graphData.agents)) {
+    if (isInternalAgent(agentData) && agentData.dataComponents) {
+      for (const dataComponentId of agentData.dataComponents) {
+        if (!availableDataComponentIds.has(dataComponentId)) {
+          errors.push(
+            `Agent '${agentId}' references non-existent dataComponent '${dataComponentId}'`
+          );
+        }
+      }
+    }
+  }
+  if (errors.length > 0) {
+    throw new Error(`DataComponent reference validation failed:
+${errors.join("\n")}`);
+  }
+}
+function validateArtifactComponentReferences(graphData) {
+  const errors = [];
+  const availableArtifactComponentIds = new Set(Object.keys(graphData.artifactComponents || {}));
+  for (const [agentId, agentData] of Object.entries(graphData.agents)) {
+    if (isInternalAgent(agentData) && agentData.artifactComponents) {
+      for (const artifactComponentId of agentData.artifactComponents) {
+        if (!availableArtifactComponentIds.has(artifactComponentId)) {
+          errors.push(
+            `Agent '${agentId}' references non-existent artifactComponent '${artifactComponentId}'`
+          );
+        }
+      }
+    }
+  }
+  if (errors.length > 0) {
+    throw new Error(`ArtifactComponent reference validation failed:
+${errors.join("\n")}`);
+  }
+}
+function validateAgentRelationships(graphData) {
+  const errors = [];
+  const availableAgentIds = new Set(Object.keys(graphData.agents));
+  for (const [agentId, agentData] of Object.entries(graphData.agents)) {
+    if (isInternalAgent(agentData)) {
+      if (agentData.canTransferTo && Array.isArray(agentData.canTransferTo)) {
+        for (const targetId of agentData.canTransferTo) {
+          if (!availableAgentIds.has(targetId)) {
+            errors.push(
+              `Agent '${agentId}' has transfer target '${targetId}' that doesn't exist in graph`
+            );
+          }
+        }
+      }
+      if (agentData.canDelegateTo && Array.isArray(agentData.canDelegateTo)) {
+        for (const targetId of agentData.canDelegateTo) {
+          if (!availableAgentIds.has(targetId)) {
+            errors.push(
+              `Agent '${agentId}' has delegation target '${targetId}' that doesn't exist in graph`
+            );
+          }
+        }
+      }
+    }
+  }
+  if (errors.length > 0) {
+    throw new Error(`Agent relationship validation failed:
+${errors.join("\n")}`);
+  }
+}
+function validateGraphStructure(graphData) {
+  if (!graphData.agents[graphData.defaultAgentId]) {
+    throw new Error(`Default agent '${graphData.defaultAgentId}' does not exist in agents`);
+  }
+  validateToolReferences(graphData);
+  validateDataComponentReferences(graphData);
+  validateArtifactComponentReferences(graphData);
+  validateAgentRelationships(graphData);
+}
+
+// src/validation/id-validation.ts
+function isValidResourceId(id) {
+  const result = resourceIdSchema.safeParse(id);
+  return result.success;
+}
+function generateIdFromName(name) {
+  const id = name.toLowerCase().replace(/[^a-z0-9_-]+/g, "-").replace(/^-+|-+$/g, "").replace(/-{2,}/g, "-");
+  if (!id) {
+    throw new Error("Cannot generate valid ID from provided name");
+  }
+  const truncatedId = id.substring(0, MAX_ID_LENGTH);
+  const result = resourceIdSchema.safeParse(truncatedId);
+  if (!result.success) {
+    throw new Error(`Generated ID "${truncatedId}" is not valid: ${result.error.message}`);
+  }
+  return truncatedId;
+}
+
+exports.AgentApiInsertSchema = AgentApiInsertSchema;
+exports.AgentApiSelectSchema = AgentApiSelectSchema;
+exports.AgentApiUpdateSchema = AgentApiUpdateSchema;
+exports.AgentArtifactComponentApiInsertSchema = AgentArtifactComponentApiInsertSchema;
+exports.AgentArtifactComponentApiSelectSchema = AgentArtifactComponentApiSelectSchema;
+exports.AgentArtifactComponentApiUpdateSchema = AgentArtifactComponentApiUpdateSchema;
+exports.AgentArtifactComponentInsertSchema = AgentArtifactComponentInsertSchema;
+exports.AgentArtifactComponentSelectSchema = AgentArtifactComponentSelectSchema;
+exports.AgentArtifactComponentUpdateSchema = AgentArtifactComponentUpdateSchema;
+exports.AgentDataComponentApiInsertSchema = AgentDataComponentApiInsertSchema;
+exports.AgentDataComponentApiSelectSchema = AgentDataComponentApiSelectSchema;
+exports.AgentDataComponentApiUpdateSchema = AgentDataComponentApiUpdateSchema;
+exports.AgentDataComponentInsertSchema = AgentDataComponentInsertSchema;
+exports.AgentDataComponentSelectSchema = AgentDataComponentSelectSchema;
+exports.AgentDataComponentUpdateSchema = AgentDataComponentUpdateSchema;
+exports.AgentGraphApiInsertSchema = AgentGraphApiInsertSchema;
+exports.AgentGraphApiSelectSchema = AgentGraphApiSelectSchema;
+exports.AgentGraphApiUpdateSchema = AgentGraphApiUpdateSchema;
+exports.AgentGraphInsertSchema = AgentGraphInsertSchema;
+exports.AgentGraphSelectSchema = AgentGraphSelectSchema;
+exports.AgentGraphUpdateSchema = AgentGraphUpdateSchema;
+exports.AgentInsertSchema = AgentInsertSchema;
+exports.AgentRelationApiInsertSchema = AgentRelationApiInsertSchema;
+exports.AgentRelationApiSelectSchema = AgentRelationApiSelectSchema;
+exports.AgentRelationApiUpdateSchema = AgentRelationApiUpdateSchema;
+exports.AgentRelationInsertSchema = AgentRelationInsertSchema;
+exports.AgentRelationQuerySchema = AgentRelationQuerySchema;
+exports.AgentRelationSelectSchema = AgentRelationSelectSchema;
+exports.AgentRelationUpdateSchema = AgentRelationUpdateSchema;
+exports.AgentSelectSchema = AgentSelectSchema;
+exports.AgentToolRelationApiInsertSchema = AgentToolRelationApiInsertSchema;
+exports.AgentToolRelationApiSelectSchema = AgentToolRelationApiSelectSchema;
+exports.AgentToolRelationApiUpdateSchema = AgentToolRelationApiUpdateSchema;
+exports.AgentToolRelationInsertSchema = AgentToolRelationInsertSchema;
+exports.AgentToolRelationSelectSchema = AgentToolRelationSelectSchema;
+exports.AgentToolRelationUpdateSchema = AgentToolRelationUpdateSchema;
+exports.AgentUpdateSchema = AgentUpdateSchema;
+exports.AllAgentSchema = AllAgentSchema;
+exports.ApiKeyApiCreationResponseSchema = ApiKeyApiCreationResponseSchema;
+exports.ApiKeyApiInsertSchema = ApiKeyApiInsertSchema;
+exports.ApiKeyApiSelectSchema = ApiKeyApiSelectSchema;
+exports.ApiKeyApiUpdateSchema = ApiKeyApiUpdateSchema;
+exports.ApiKeyInsertSchema = ApiKeyInsertSchema;
+exports.ApiKeySelectSchema = ApiKeySelectSchema;
+exports.ApiKeyUpdateSchema = ApiKeyUpdateSchema;
+exports.ArtifactComponentApiInsertSchema = ArtifactComponentApiInsertSchema;
+exports.ArtifactComponentApiSelectSchema = ArtifactComponentApiSelectSchema;
+exports.ArtifactComponentApiUpdateSchema = ArtifactComponentApiUpdateSchema;
+exports.ArtifactComponentInsertSchema = ArtifactComponentInsertSchema;
+exports.ArtifactComponentSelectSchema = ArtifactComponentSelectSchema;
+exports.ArtifactComponentUpdateSchema = ArtifactComponentUpdateSchema;
+exports.ContextCacheApiInsertSchema = ContextCacheApiInsertSchema;
+exports.ContextCacheApiSelectSchema = ContextCacheApiSelectSchema;
+exports.ContextCacheApiUpdateSchema = ContextCacheApiUpdateSchema;
+exports.ContextCacheInsertSchema = ContextCacheInsertSchema;
+exports.ContextCacheSelectSchema = ContextCacheSelectSchema;
+exports.ContextCacheUpdateSchema = ContextCacheUpdateSchema;
+exports.ContextConfigApiInsertSchema = ContextConfigApiInsertSchema;
+exports.ContextConfigApiSelectSchema = ContextConfigApiSelectSchema;
+exports.ContextConfigApiUpdateSchema = ContextConfigApiUpdateSchema;
+exports.ContextConfigInsertSchema = ContextConfigInsertSchema;
+exports.ContextConfigSelectSchema = ContextConfigSelectSchema;
+exports.ContextConfigUpdateSchema = ContextConfigUpdateSchema;
+exports.ConversationApiInsertSchema = ConversationApiInsertSchema;
+exports.ConversationApiSelectSchema = ConversationApiSelectSchema;
+exports.ConversationApiUpdateSchema = ConversationApiUpdateSchema;
+exports.ConversationInsertSchema = ConversationInsertSchema;
+exports.ConversationSelectSchema = ConversationSelectSchema;
+exports.ConversationUpdateSchema = ConversationUpdateSchema;
+exports.CredentialReferenceApiInsertSchema = CredentialReferenceApiInsertSchema;
+exports.CredentialReferenceApiSelectSchema = CredentialReferenceApiSelectSchema;
+exports.CredentialReferenceApiUpdateSchema = CredentialReferenceApiUpdateSchema;
+exports.CredentialReferenceInsertSchema = CredentialReferenceInsertSchema;
+exports.CredentialReferenceSelectSchema = CredentialReferenceSelectSchema;
+exports.CredentialReferenceUpdateSchema = CredentialReferenceUpdateSchema;
+exports.DataComponentApiInsertSchema = DataComponentApiInsertSchema;
+exports.DataComponentApiSelectSchema = DataComponentApiSelectSchema;
+exports.DataComponentApiUpdateSchema = DataComponentApiUpdateSchema;
+exports.DataComponentBaseSchema = DataComponentBaseSchema;
+exports.DataComponentInsertSchema = DataComponentInsertSchema;
+exports.DataComponentSelectSchema = DataComponentSelectSchema;
+exports.DataComponentUpdateSchema = DataComponentUpdateSchema;
+exports.ErrorResponseSchema = ErrorResponseSchema;
+exports.ExistsResponseSchema = ExistsResponseSchema;
+exports.ExternalAgentApiInsertSchema = ExternalAgentApiInsertSchema;
+exports.ExternalAgentApiSelectSchema = ExternalAgentApiSelectSchema;
+exports.ExternalAgentApiUpdateSchema = ExternalAgentApiUpdateSchema;
+exports.ExternalAgentInsertSchema = ExternalAgentInsertSchema;
+exports.ExternalAgentRelationApiInsertSchema = ExternalAgentRelationApiInsertSchema;
+exports.ExternalAgentRelationInsertSchema = ExternalAgentRelationInsertSchema;
+exports.ExternalAgentSelectSchema = ExternalAgentSelectSchema;
+exports.ExternalAgentUpdateSchema = ExternalAgentUpdateSchema;
+exports.FetchConfigSchema = FetchConfigSchema;
+exports.FetchDefinitionSchema = FetchDefinitionSchema;
+exports.FullGraphAgentInsertSchema = FullGraphAgentInsertSchema;
+exports.FullGraphDefinitionSchema = FullGraphDefinitionSchema;
+exports.HeadersScopeSchema = HeadersScopeSchema;
+exports.IdParamsSchema = IdParamsSchema;
+exports.LedgerArtifactApiInsertSchema = LedgerArtifactApiInsertSchema;
+exports.LedgerArtifactApiSelectSchema = LedgerArtifactApiSelectSchema;
+exports.LedgerArtifactApiUpdateSchema = LedgerArtifactApiUpdateSchema;
+exports.LedgerArtifactInsertSchema = LedgerArtifactInsertSchema;
+exports.LedgerArtifactSelectSchema = LedgerArtifactSelectSchema;
+exports.LedgerArtifactUpdateSchema = LedgerArtifactUpdateSchema;
+exports.ListResponseSchema = ListResponseSchema;
+exports.MAX_ID_LENGTH = MAX_ID_LENGTH;
+exports.MCPToolConfigSchema = MCPToolConfigSchema;
+exports.MIN_ID_LENGTH = MIN_ID_LENGTH;
+exports.McpToolDefinitionSchema = McpToolDefinitionSchema;
+exports.McpToolSchema = McpToolSchema;
+exports.McpTransportConfigSchema = McpTransportConfigSchema;
+exports.MessageApiInsertSchema = MessageApiInsertSchema;
+exports.MessageApiSelectSchema = MessageApiSelectSchema;
+exports.MessageApiUpdateSchema = MessageApiUpdateSchema;
+exports.MessageInsertSchema = MessageInsertSchema;
+exports.MessageSelectSchema = MessageSelectSchema;
+exports.MessageUpdateSchema = MessageUpdateSchema;
+exports.ModelSchema = ModelSchema;
+exports.ModelSettingsSchema = ModelSettingsSchema;
+exports.PaginationQueryParamsSchema = PaginationQueryParamsSchema;
+exports.PaginationSchema = PaginationSchema;
+exports.ProjectApiInsertSchema = ProjectApiInsertSchema;
+exports.ProjectApiSelectSchema = ProjectApiSelectSchema;
+exports.ProjectApiUpdateSchema = ProjectApiUpdateSchema;
+exports.ProjectInsertSchema = ProjectInsertSchema;
+exports.ProjectModelSchema = ProjectModelSchema;
+exports.ProjectSelectSchema = ProjectSelectSchema;
+exports.ProjectUpdateSchema = ProjectUpdateSchema;
+exports.RemovedResponseSchema = RemovedResponseSchema;
+exports.SingleResponseSchema = SingleResponseSchema;
+exports.StatusComponentSchema = StatusComponentSchema;
+exports.StatusUpdateSchema = StatusUpdateSchema;
+exports.TaskApiInsertSchema = TaskApiInsertSchema;
+exports.TaskApiSelectSchema = TaskApiSelectSchema;
+exports.TaskApiUpdateSchema = TaskApiUpdateSchema;
+exports.TaskInsertSchema = TaskInsertSchema;
+exports.TaskRelationApiInsertSchema = TaskRelationApiInsertSchema;
+exports.TaskRelationApiSelectSchema = TaskRelationApiSelectSchema;
+exports.TaskRelationApiUpdateSchema = TaskRelationApiUpdateSchema;
+exports.TaskRelationInsertSchema = TaskRelationInsertSchema;
+exports.TaskRelationSelectSchema = TaskRelationSelectSchema;
+exports.TaskRelationUpdateSchema = TaskRelationUpdateSchema;
+exports.TaskSelectSchema = TaskSelectSchema;
+exports.TaskUpdateSchema = TaskUpdateSchema;
+exports.TenantIdParamsSchema = TenantIdParamsSchema;
+exports.TenantParamsSchema = TenantParamsSchema;
+exports.TenantProjectIdParamsSchema = TenantProjectIdParamsSchema;
+exports.TenantProjectParamsSchema = TenantProjectParamsSchema;
+exports.ToolApiInsertSchema = ToolApiInsertSchema;
+exports.ToolApiSelectSchema = ToolApiSelectSchema;
+exports.ToolApiUpdateSchema = ToolApiUpdateSchema;
+exports.ToolInsertSchema = ToolInsertSchema;
+exports.ToolSelectSchema = ToolSelectSchema;
+exports.ToolStatusSchema = ToolStatusSchema;
+exports.ToolUpdateSchema = ToolUpdateSchema;
+exports.URL_SAFE_ID_PATTERN = URL_SAFE_ID_PATTERN;
+exports.generateIdFromName = generateIdFromName;
+exports.isExternalAgent = isExternalAgent;
+exports.isInternalAgent = isInternalAgent;
+exports.isValidResourceId = isValidResourceId;
+exports.resourceIdSchema = resourceIdSchema;
+exports.validateAgentRelationships = validateAgentRelationships;
+exports.validateAndTypeGraphData = validateAndTypeGraphData;
+exports.validateArtifactComponentReferences = validateArtifactComponentReferences;
+exports.validateDataComponentReferences = validateDataComponentReferences;
+exports.validateGraphStructure = validateGraphStructure;
+exports.validateToolReferences = validateToolReferences;