@inkeep/agents-core 0.1.4 → 0.1.7

package/dist/db/schema.cjs

@@ -0,0 +1,922 @@
+'use strict';
+
+var drizzleOrm = require('drizzle-orm');
+var sqliteCore = require('drizzle-orm/sqlite-core');
+
+// src/db/schema.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 settings 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] }),
+    sqliteCore.foreignKey({
+      columns: [table.tenantId, table.projectId],
+      foreignColumns: [projects.tenantId, projects.id],
+      name: "context_configs_project_fk"
+    }).onDelete("cascade")
+  ]
+);
+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.foreignKey({
+      columns: [table.tenantId, table.projectId],
+      foreignColumns: [projects.tenantId, projects.id],
+      name: "context_cache_project_fk"
+    }).onDelete("cascade"),
+    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"
+    }).onDelete("cascade")
+  ]
+);
+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"
+    }).onDelete("cascade")
+  ]
+);
+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],
+      foreignColumns: [projects.tenantId, projects.id],
+      name: "external_agents_project_fk"
+    }).onDelete("cascade"),
+    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"
+    }).onDelete("cascade")
+  ]
+);
+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] }),
+    sqliteCore.foreignKey({
+      columns: [table.tenantId, table.projectId],
+      foreignColumns: [projects.tenantId, projects.id],
+      name: "tasks_project_fk"
+    }).onDelete("cascade")
+  ]
+);
+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] }),
+    sqliteCore.foreignKey({
+      columns: [table.tenantId, table.projectId],
+      foreignColumns: [projects.tenantId, projects.id],
+      name: "task_relations_project_fk"
+    }).onDelete("cascade")
+  ]
+);
+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] }),
+    sqliteCore.foreignKey({
+      columns: [table.tenantId, table.projectId],
+      foreignColumns: [projects.tenantId, projects.id],
+      name: "data_components_project_fk"
+    }).onDelete("cascade")
+  ]
+);
+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 projects table
+    sqliteCore.foreignKey({
+      columns: [table.tenantId, table.projectId],
+      foreignColumns: [projects.tenantId, projects.id],
+      name: "agent_data_components_project_fk"
+    }).onDelete("cascade"),
+    // 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] }),
+    sqliteCore.foreignKey({
+      columns: [table.tenantId, table.projectId],
+      foreignColumns: [projects.tenantId, projects.id],
+      name: "artifact_components_project_fk"
+    }).onDelete("cascade")
+  ]
+);
+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 projects table
+    sqliteCore.foreignKey({
+      columns: [table.tenantId, table.projectId],
+      foreignColumns: [projects.tenantId, projects.id],
+      name: "agent_artifact_components_project_fk"
+    }).onDelete("cascade"),
+    // 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] }),
+    sqliteCore.foreignKey({
+      columns: [table.tenantId, table.projectId],
+      foreignColumns: [projects.tenantId, projects.id],
+      name: "tools_project_fk"
+    }).onDelete("cascade")
+  ]
+);
+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 projects table
+    sqliteCore.foreignKey({
+      columns: [table.tenantId, table.projectId],
+      foreignColumns: [projects.tenantId, projects.id],
+      name: "agent_tool_relations_project_fk"
+    }).onDelete("cascade"),
+    // 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] }),
+    sqliteCore.foreignKey({
+      columns: [table.tenantId, table.projectId],
+      foreignColumns: [projects.tenantId, projects.id],
+      name: "conversations_project_fk"
+    }).onDelete("cascade")
+  ]
+);
+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] }),
+    sqliteCore.foreignKey({
+      columns: [table.tenantId, table.projectId],
+      foreignColumns: [projects.tenantId, projects.id],
+      name: "messages_project_fk"
+    }).onDelete("cascade")
+  ]
+);
+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] }),
+    sqliteCore.foreignKey({
+      columns: [table.tenantId, table.projectId],
+      foreignColumns: [projects.tenantId, projects.id],
+      name: "ledger_artifacts_project_fk"
+    }).onDelete("cascade")
+  ]
+);
+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],
+      foreignColumns: [projects.tenantId, projects.id],
+      name: "api_keys_project_fk"
+    }).onDelete("cascade"),
+    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.foreignKey({
+      columns: [t.tenantId, t.projectId],
+      foreignColumns: [projects.tenantId, projects.id],
+      name: "credential_references_project_fk"
+    }).onDelete("cascade")
+  ]
+);
+var ledgerArtifactsTaskIdIdx = sqliteCore.index("ledger_artifacts_task_id_idx").on(
+  ledgerArtifacts.taskId
+);
+var ledgerArtifactsContextIdIdx = sqliteCore.index("ledger_artifacts_context_id_idx").on(
+  ledgerArtifacts.contextId
+);
+var ledgerArtifactsTaskContextNameUnique = sqliteCore.unique(
+  "ledger_artifacts_task_context_name_unique"
+).on(ledgerArtifacts.taskId, ledgerArtifacts.contextId, ledgerArtifacts.name);
+var tasksRelations = 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)
+}));
+var projectsRelations = 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)
+}));
+var taskRelationsRelations = 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"
+  })
+}));
+var contextConfigsRelations = 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)
+}));
+var contextCacheRelations = drizzleOrm.relations(contextCache, ({ one }) => ({
+  // Each cache entry belongs to one context config
+  contextConfig: one(contextConfigs, {
+    fields: [contextCache.contextConfigId],
+    references: [contextConfigs.id]
+  })
+}));
+var agentsRelations = 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)
+}));
+var agentGraphRelations = 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]
+  })
+}));
+var externalAgentsRelations = 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]
+  })
+}));
+var apiKeysRelations = 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]
+  })
+}));
+var agentToolRelationsRelations = 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]
+  })
+}));
+var credentialReferencesRelations = drizzleOrm.relations(credentialReferences, ({ many }) => ({
+  tools: many(tools)
+}));
+var toolsRelations = 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]
+  })
+}));
+var conversationsRelations = 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]
+  })
+}));
+var messagesRelations = 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"
+  })
+}));
+var artifactComponentsRelations = drizzleOrm.relations(artifactComponents, ({ many }) => ({
+  // An artifact component can be associated with many agents
+  agentRelations: many(agentArtifactComponents)
+}));
+var agentArtifactComponentsRelations = 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]
+  })
+}));
+var agentRelationsRelations = 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]
+  })
+}));
+
+exports.agentArtifactComponents = agentArtifactComponents;
+exports.agentArtifactComponentsRelations = agentArtifactComponentsRelations;
+exports.agentDataComponents = agentDataComponents;
+exports.agentGraph = agentGraph;
+exports.agentGraphRelations = agentGraphRelations;
+exports.agentRelations = agentRelations;
+exports.agentRelationsRelations = agentRelationsRelations;
+exports.agentToolRelations = agentToolRelations;
+exports.agentToolRelationsRelations = agentToolRelationsRelations;
+exports.agents = agents;
+exports.agentsRelations = agentsRelations;
+exports.apiKeys = apiKeys;
+exports.apiKeysRelations = apiKeysRelations;
+exports.artifactComponents = artifactComponents;
+exports.artifactComponentsRelations = artifactComponentsRelations;
+exports.contextCache = contextCache;
+exports.contextCacheRelations = contextCacheRelations;
+exports.contextConfigs = contextConfigs;
+exports.contextConfigsRelations = contextConfigsRelations;
+exports.conversations = conversations;
+exports.conversationsRelations = conversationsRelations;
+exports.credentialReferences = credentialReferences;
+exports.credentialReferencesRelations = credentialReferencesRelations;
+exports.dataComponents = dataComponents;
+exports.externalAgents = externalAgents;
+exports.externalAgentsRelations = externalAgentsRelations;
+exports.ledgerArtifacts = ledgerArtifacts;
+exports.ledgerArtifactsContextIdIdx = ledgerArtifactsContextIdIdx;
+exports.ledgerArtifactsTaskContextNameUnique = ledgerArtifactsTaskContextNameUnique;
+exports.ledgerArtifactsTaskIdIdx = ledgerArtifactsTaskIdIdx;
+exports.messages = messages;
+exports.messagesRelations = messagesRelations;
+exports.projects = projects;
+exports.projectsRelations = projectsRelations;
+exports.taskRelations = taskRelations;
+exports.taskRelationsRelations = taskRelationsRelations;
+exports.tasks = tasks;
+exports.tasksRelations = tasksRelations;
+exports.tools = tools;
+exports.toolsRelations = toolsRelations;