@inkeep/agents-core 0.1.4 → 0.1.6

package/dist/chunk-M4JXMAG7.js

@@ -0,0 +1,822 @@
+import { __export } from './chunk-MKBO26DX.js';
+import { relations, sql } from 'drizzle-orm';
+import { sqliteTable, index, unique, text, primaryKey, blob, integer, foreignKey } from 'drizzle-orm/sqlite-core';
+
+// src/db/schema.ts
+var schema_exports = {};
+__export(schema_exports, {
+  agentArtifactComponents: () => agentArtifactComponents,
+  agentArtifactComponentsRelations: () => agentArtifactComponentsRelations,
+  agentDataComponents: () => agentDataComponents,
+  agentGraph: () => agentGraph,
+  agentGraphRelations: () => agentGraphRelations,
+  agentRelations: () => agentRelations,
+  agentRelationsRelations: () => agentRelationsRelations,
+  agentToolRelations: () => agentToolRelations,
+  agentToolRelationsRelations: () => agentToolRelationsRelations,
+  agents: () => agents,
+  agentsRelations: () => agentsRelations,
+  apiKeys: () => apiKeys,
+  apiKeysRelations: () => apiKeysRelations,
+  artifactComponents: () => artifactComponents,
+  artifactComponentsRelations: () => artifactComponentsRelations,
+  contextCache: () => contextCache,
+  contextCacheRelations: () => contextCacheRelations,
+  contextConfigs: () => contextConfigs,
+  contextConfigsRelations: () => contextConfigsRelations,
+  conversations: () => conversations,
+  conversationsRelations: () => conversationsRelations,
+  credentialReferences: () => credentialReferences,
+  credentialReferencesRelations: () => credentialReferencesRelations,
+  dataComponents: () => dataComponents,
+  externalAgents: () => externalAgents,
+  externalAgentsRelations: () => externalAgentsRelations,
+  ledgerArtifacts: () => ledgerArtifacts,
+  ledgerArtifactsContextIdIdx: () => ledgerArtifactsContextIdIdx,
+  ledgerArtifactsTaskContextNameUnique: () => ledgerArtifactsTaskContextNameUnique,
+  ledgerArtifactsTaskIdIdx: () => ledgerArtifactsTaskIdIdx,
+  messages: () => messages,
+  messagesRelations: () => messagesRelations,
+  projects: () => projects,
+  projectsRelations: () => projectsRelations,
+  taskRelations: () => taskRelations,
+  taskRelationsRelations: () => taskRelationsRelations,
+  tasks: () => tasks,
+  tasksRelations: () => tasksRelations,
+  tools: () => tools,
+  toolsRelations: () => toolsRelations
+});
+var projects = sqliteTable(
+  "projects",
+  {
+    tenantId: text("tenant_id").notNull(),
+    id: text("id").notNull(),
+    // This IS the project ID
+    name: text("name").notNull(),
+    description: text("description").notNull(),
+    // Project-level default model settingsuration that can be inherited by graphs and agents
+    models: text("models", { mode: "json" }).$type(),
+    // Project-level stopWhen configuration that can be inherited by graphs and agents
+    stopWhen: text("stop_when", { mode: "json" }).$type(),
+    createdAt: text("created_at").notNull().default(sql`CURRENT_TIMESTAMP`),
+    updatedAt: text("updated_at").notNull().default(sql`CURRENT_TIMESTAMP`)
+  },
+  (table) => [primaryKey({ columns: [table.tenantId, table.id] })]
+);
+var contextConfigs = sqliteTable(
+  "context_configs",
+  {
+    tenantId: text("tenant_id").notNull(),
+    projectId: text("project_id").notNull(),
+    id: text("id").notNull(),
+    name: text("name").notNull(),
+    description: text("description").notNull(),
+    // Developer-defined Zod schema for validating incoming request context
+    requestContextSchema: blob("request_context_schema", { mode: "json" }).$type(),
+    // Stores serialized Zod schema
+    // Object mapping template keys to fetch definitions that use request context data
+    contextVariables: blob("context_variables", { mode: "json" }).$type(),
+    createdAt: text("created_at").notNull().default(sql`CURRENT_TIMESTAMP`),
+    updatedAt: text("updated_at").notNull().default(sql`CURRENT_TIMESTAMP`)
+  },
+  (table) => [primaryKey({ columns: [table.tenantId, table.projectId, table.id] })]
+);
+var contextCache = sqliteTable(
+  "context_cache",
+  {
+    tenantId: text("tenant_id").notNull(),
+    projectId: text("project_id").notNull(),
+    id: text("id").notNull(),
+    // Always scoped to conversation for complete data isolation
+    conversationId: text("conversation_id").notNull(),
+    // Reference to the context config and specific fetch definition
+    contextConfigId: text("context_config_id").notNull(),
+    contextVariableKey: text("context_variable_key").notNull(),
+    // Key from contextVariables object
+    // The actual cached context data
+    value: blob("value", { mode: "json" }).$type().notNull(),
+    // Request hash for cache invalidation based on context changes
+    requestHash: text("request_hash"),
+    // Hash of request context that triggered this cache
+    // Metadata for monitoring and debugging
+    fetchedAt: text("fetched_at").notNull(),
+    fetchSource: text("fetch_source"),
+    // URL or source identifier
+    fetchDurationMs: integer("fetch_duration_ms"),
+    createdAt: text("created_at").notNull().default(sql`CURRENT_TIMESTAMP`),
+    updatedAt: text("updated_at").notNull().default(sql`CURRENT_TIMESTAMP`)
+  },
+  (table) => [
+    primaryKey({ columns: [table.tenantId, table.projectId, table.id] }),
+    index("context_cache_lookup_idx").on(
+      table.conversationId,
+      table.contextConfigId,
+      table.contextVariableKey
+    )
+  ]
+);
+var agents = sqliteTable(
+  "agents",
+  {
+    tenantId: text("tenant_id").notNull(),
+    projectId: text("project_id").notNull(),
+    id: text("id").notNull(),
+    name: text("name").notNull(),
+    description: text("description").notNull(),
+    prompt: text("prompt").notNull(),
+    conversationHistoryConfig: text("conversation_history_config", {
+      mode: "json"
+    }).$type(),
+    models: text("models", { mode: "json" }).$type(),
+    // Agent-level stopWhen configuration (inherited from project)
+    stopWhen: text("stop_when", { mode: "json" }).$type(),
+    createdAt: text("created_at").notNull().default(sql`CURRENT_TIMESTAMP`),
+    updatedAt: text("updated_at").notNull().default(sql`CURRENT_TIMESTAMP`)
+  },
+  (table) => [
+    primaryKey({ columns: [table.tenantId, table.projectId, table.id] }),
+    foreignKey({
+      columns: [table.tenantId, table.projectId],
+      foreignColumns: [projects.tenantId, projects.id],
+      name: "agents_project_fk"
+    })
+  ]
+);
+var agentRelations = sqliteTable(
+  "agent_relations",
+  {
+    tenantId: text("tenant_id").notNull(),
+    projectId: text("project_id").notNull(),
+    id: text("id").notNull(),
+    graphId: text("graph_id").notNull(),
+    sourceAgentId: text("source_agent_id").notNull(),
+    // For internal relationships
+    targetAgentId: text("target_agent_id"),
+    // For external relationships
+    externalAgentId: text("external_agent_id"),
+    relationType: text("relation_type"),
+    // 'transfer' | 'delegate'
+    createdAt: text("created_at").notNull().default(sql`CURRENT_TIMESTAMP`),
+    updatedAt: text("updated_at").notNull().default(sql`CURRENT_TIMESTAMP`)
+  },
+  (table) => [
+    primaryKey({ columns: [table.tenantId, table.projectId, table.id] }),
+    foreignKey({
+      columns: [table.tenantId, table.projectId],
+      foreignColumns: [projects.tenantId, projects.id],
+      name: "agent_relations_project_fk"
+    })
+  ]
+);
+var externalAgents = sqliteTable(
+  "external_agents",
+  {
+    tenantId: text("tenant_id").notNull(),
+    projectId: text("project_id").notNull(),
+    id: text("id").notNull(),
+    name: text("name").notNull(),
+    description: text("description").notNull(),
+    baseUrl: text("base_url").notNull(),
+    // A2A endpoint URL
+    credentialReferenceId: text("credential_reference_id"),
+    headers: blob("headers", { mode: "json" }).$type(),
+    createdAt: text("created_at").notNull().default(sql`CURRENT_TIMESTAMP`),
+    updatedAt: text("updated_at").notNull().default(sql`CURRENT_TIMESTAMP`)
+  },
+  (table) => [
+    primaryKey({ columns: [table.tenantId, table.projectId, table.id] }),
+    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 = sqliteTable(
+  "agent_graph",
+  {
+    tenantId: text("tenant_id").notNull(),
+    projectId: text("project_id").notNull(),
+    id: text("id").notNull(),
+    name: text("name").notNull(),
+    description: text("description"),
+    defaultAgentId: text("default_agent_id").notNull(),
+    // Reference to shared context configuration for all agents in this graph
+    contextConfigId: text("context_config_id"),
+    // Graph-level model settingsuration that can be inherited by agents
+    models: text("models", { mode: "json" }).$type(),
+    // Status updates configuration for intelligent progress summaries
+    statusUpdates: text("status_updates", { mode: "json" }).$type(),
+    // Graph-level prompt that can be used as additional context for agents
+    graphPrompt: text("graph_prompt"),
+    // Graph-level stopWhen configuration that can be inherited by agents
+    stopWhen: text("stop_when", { mode: "json" }).$type(),
+    createdAt: text("created_at").notNull().default(sql`CURRENT_TIMESTAMP`),
+    updatedAt: text("updated_at").notNull().default(sql`CURRENT_TIMESTAMP`)
+  },
+  (table) => [
+    primaryKey({ columns: [table.tenantId, table.projectId, table.id] }),
+    foreignKey({
+      columns: [table.tenantId, table.projectId],
+      foreignColumns: [projects.tenantId, projects.id],
+      name: "agent_graph_project_fk"
+    })
+  ]
+);
+var tasks = sqliteTable(
+  "tasks",
+  {
+    tenantId: text("tenant_id").notNull(),
+    projectId: text("project_id").notNull(),
+    id: text("id").notNull(),
+    contextId: text("context_id").notNull(),
+    status: text("status").notNull(),
+    metadata: blob("metadata", { mode: "json" }).$type(),
+    agentId: text("agent_id").notNull(),
+    createdAt: text("created_at").notNull().default(sql`CURRENT_TIMESTAMP`),
+    updatedAt: text("updated_at").notNull().default(sql`CURRENT_TIMESTAMP`)
+  },
+  (table) => [primaryKey({ columns: [table.tenantId, table.projectId, table.id] })]
+);
+var taskRelations = sqliteTable(
+  "task_relations",
+  {
+    tenantId: text("tenant_id").notNull(),
+    projectId: text("project_id").notNull(),
+    id: text("id").notNull(),
+    parentTaskId: text("parent_task_id").notNull(),
+    childTaskId: text("child_task_id").notNull(),
+    relationType: text("relation_type").default("parent_child"),
+    // Could be extended for other relation types
+    createdAt: text("created_at").notNull().default(sql`CURRENT_TIMESTAMP`),
+    updatedAt: text("updated_at").notNull().default(sql`CURRENT_TIMESTAMP`)
+  },
+  (table) => [primaryKey({ columns: [table.tenantId, table.projectId, table.id] })]
+);
+var dataComponents = sqliteTable(
+  "data_components",
+  {
+    tenantId: text("tenant_id").notNull(),
+    projectId: text("project_id").notNull(),
+    id: text("id").notNull(),
+    name: text("name").notNull(),
+    description: text("description").notNull(),
+    props: blob("props", { mode: "json" }).$type(),
+    createdAt: text("created_at").notNull().default(sql`CURRENT_TIMESTAMP`),
+    updatedAt: text("updated_at").notNull().default(sql`CURRENT_TIMESTAMP`)
+  },
+  (table) => [primaryKey({ columns: [table.tenantId, table.projectId, table.id] })]
+);
+var agentDataComponents = sqliteTable(
+  "agent_data_components",
+  {
+    tenantId: text("tenant_id").notNull(),
+    projectId: text("project_id").notNull(),
+    id: text("id").notNull(),
+    agentId: text("agent_id").notNull(),
+    dataComponentId: text("data_component_id").notNull(),
+    createdAt: text("created_at").notNull().default(sql`CURRENT_TIMESTAMP`)
+  },
+  (table) => [
+    primaryKey({ columns: [table.tenantId, table.projectId, table.id] }),
+    // Foreign key constraint to agents table
+    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
+    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 = sqliteTable(
+  "artifact_components",
+  {
+    tenantId: text("tenant_id").notNull(),
+    projectId: text("project_id").notNull(),
+    id: text("id").notNull(),
+    name: text("name").notNull(),
+    description: text("description").notNull(),
+    summaryProps: blob("summary_props", { mode: "json" }).$type(),
+    fullProps: blob("full_props", { mode: "json" }).$type(),
+    createdAt: text("created_at").notNull().default(sql`CURRENT_TIMESTAMP`),
+    updatedAt: text("updated_at").notNull().default(sql`CURRENT_TIMESTAMP`)
+  },
+  (table) => [primaryKey({ columns: [table.tenantId, table.projectId, table.id] })]
+);
+var agentArtifactComponents = sqliteTable(
+  "agent_artifact_components",
+  {
+    tenantId: text("tenant_id").notNull(),
+    projectId: text("project_id").notNull(),
+    id: text("id").notNull(),
+    agentId: text("agent_id").notNull(),
+    artifactComponentId: text("artifact_component_id").notNull(),
+    createdAt: text("created_at").notNull().default(sql`CURRENT_TIMESTAMP`)
+  },
+  (table) => [
+    primaryKey({ columns: [table.tenantId, table.projectId, table.id] }),
+    // Foreign key constraint to agents table
+    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
+    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 = sqliteTable(
+  "tools",
+  {
+    tenantId: text("tenant_id").notNull(),
+    projectId: text("project_id").notNull(),
+    id: text("id").notNull(),
+    name: text("name").notNull(),
+    // Enhanced MCP configuration
+    config: blob("config", { mode: "json" }).$type().notNull(),
+    credentialReferenceId: text("credential_reference_id"),
+    headers: blob("headers", { mode: "json" }).$type(),
+    // Image URL for custom tool icon (supports regular URLs and base64 encoded images)
+    imageUrl: text("image_url"),
+    // Server capabilities and status
+    capabilities: blob("capabilities", { mode: "json" }).$type(),
+    // Connection health and monitoring
+    status: text("status").notNull().default("unknown"),
+    lastHealthCheck: text("last_health_check"),
+    lastError: text("last_error"),
+    // Tool discovery cache
+    availableTools: blob("available_tools", { mode: "json" }).$type(),
+    lastToolsSync: text("last_tools_sync"),
+    createdAt: text("created_at").notNull().default(sql`CURRENT_TIMESTAMP`),
+    updatedAt: text("updated_at").notNull().default(sql`CURRENT_TIMESTAMP`)
+  },
+  (table) => [primaryKey({ columns: [table.tenantId, table.projectId, table.id] })]
+);
+var agentToolRelations = sqliteTable(
+  "agent_tool_relations",
+  {
+    tenantId: text("tenant_id").notNull(),
+    projectId: text("project_id").notNull(),
+    id: text("id").notNull(),
+    agentId: text("agent_id").notNull(),
+    toolId: text("tool_id").notNull(),
+    selectedTools: blob("selected_tools", { mode: "json" }).$type(),
+    createdAt: text("created_at").notNull().default(sql`CURRENT_TIMESTAMP`),
+    updatedAt: text("updated_at").notNull().default(sql`CURRENT_TIMESTAMP`)
+  },
+  (table) => [
+    primaryKey({ columns: [table.tenantId, table.projectId, table.id] }),
+    // Foreign key constraint to agents table
+    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
+    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 = sqliteTable(
+  "conversations",
+  {
+    tenantId: text("tenant_id").notNull(),
+    projectId: text("project_id").notNull(),
+    id: text("id").notNull(),
+    userId: text("user_id"),
+    activeAgentId: text("active_agent_id").notNull(),
+    title: text("title"),
+    lastContextResolution: text("last_context_resolution"),
+    metadata: blob("metadata", { mode: "json" }).$type(),
+    createdAt: text("created_at").notNull().default(sql`CURRENT_TIMESTAMP`),
+    updatedAt: text("updated_at").notNull().default(sql`CURRENT_TIMESTAMP`)
+  },
+  (table) => [primaryKey({ columns: [table.tenantId, table.projectId, table.id] })]
+);
+var messages = sqliteTable(
+  "messages",
+  {
+    tenantId: text("tenant_id").notNull(),
+    projectId: text("project_id").notNull(),
+    id: text("id").notNull(),
+    conversationId: text("conversation_id").notNull(),
+    // Role mapping: user, agent, system (unified for both formats)
+    role: text("role").notNull(),
+    // 'user' | 'agent' | 'system'
+    // Agent sender/recipient tracking (nullable - only populated when relevant)
+    fromAgentId: text("from_agent_id"),
+    // Populated when message is from an agent
+    toAgentId: text("to_agent_id"),
+    // Populated when message is directed to a specific agent (e.g., transfers/delegations)
+    // External agent sender tracking
+    fromExternalAgentId: text("from_external_agent_id"),
+    // Populated when message is directed from an external agent
+    // External agent recipient tracking
+    toExternalAgentId: text("to_external_agent_id"),
+    // Populated when message is directed to an external agent
+    // Message content stored as JSON to support both formats
+    content: blob("content", { mode: "json" }).$type().notNull(),
+    // Message classification and filtering
+    visibility: text("visibility").notNull().default("user-facing"),
+    // 'user-facing' | 'internal' | 'system' | 'external'
+    messageType: 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: text("agent_id"),
+    taskId: text("task_id"),
+    parentMessageId: text("parent_message_id"),
+    // Remove self-reference constraint here
+    // A2A specific fields
+    a2aTaskId: text("a2a_task_id"),
+    // Links to A2A task when relevant
+    a2aSessionId: text("a2a_session_id"),
+    // A2A session identifier
+    // Metadata for extensions
+    metadata: blob("metadata", { mode: "json" }).$type(),
+    createdAt: text("created_at").notNull().default(sql`CURRENT_TIMESTAMP`),
+    updatedAt: text("updated_at").notNull().default(sql`CURRENT_TIMESTAMP`)
+  },
+  (table) => [primaryKey({ columns: [table.tenantId, table.projectId, table.id] })]
+);
+var ledgerArtifacts = sqliteTable(
+  "ledger_artifacts",
+  {
+    // Primary identifier (maps to `artifactId`)
+    tenantId: text("tenant_id").notNull(),
+    projectId: text("project_id").notNull(),
+    id: text("id").notNull(),
+    // Links
+    taskId: text("task_id"),
+    contextId: text("context_id").notNull(),
+    // Core Artifact fields
+    type: text("type").notNull().default("source"),
+    name: text("name"),
+    description: text("description"),
+    parts: blob("parts", { mode: "json" }).$type(),
+    metadata: blob("metadata", { mode: "json" }).$type(),
+    // Extra ledger information (not part of the Artifact spec – kept optional)
+    summary: text("summary"),
+    mime: blob("mime", { mode: "json" }).$type(),
+    visibility: text("visibility").default("context"),
+    allowedAgents: blob("allowed_agents", { mode: "json" }).$type(),
+    derivedFrom: text("derived_from"),
+    // Timestamps
+    createdAt: text("created_at").notNull().default(sql`CURRENT_TIMESTAMP`),
+    updatedAt: text("updated_at").notNull().default(sql`CURRENT_TIMESTAMP`)
+  },
+  (table) => [primaryKey({ columns: [table.tenantId, table.projectId, table.id] })]
+);
+var apiKeys = sqliteTable(
+  "api_keys",
+  {
+    id: text("id").primaryKey(),
+    tenantId: text("tenant_id").notNull(),
+    projectId: text("project_id").notNull(),
+    graphId: text("graph_id").notNull(),
+    publicId: text("public_id").notNull().unique(),
+    // Public ID for O(1) lookup (e.g., "abc123def456")
+    keyHash: text("key_hash").notNull(),
+    // Hashed API key (never store plaintext)
+    keyPrefix: text("key_prefix").notNull(),
+    // First 8 chars for identification (e.g., "sk_live_abc...")
+    lastUsedAt: text("last_used_at"),
+    expiresAt: text("expires_at"),
+    createdAt: text("created_at").notNull().default(sql`CURRENT_TIMESTAMP`),
+    updatedAt: text("updated_at").notNull().default(sql`CURRENT_TIMESTAMP`)
+  },
+  (t) => [
+    foreignKey({
+      columns: [t.tenantId, t.projectId, t.graphId],
+      foreignColumns: [agentGraph.tenantId, agentGraph.projectId, agentGraph.id],
+      name: "api_keys_graph_fk"
+    }).onDelete("cascade"),
+    index("api_keys_tenant_graph_idx").on(t.tenantId, t.graphId),
+    index("api_keys_prefix_idx").on(t.keyPrefix),
+    index("api_keys_public_id_idx").on(t.publicId)
+  ]
+);
+var credentialReferences = sqliteTable(
+  "credential_references",
+  {
+    tenantId: text("tenant_id").notNull(),
+    projectId: text("project_id").notNull(),
+    id: text("id").notNull(),
+    type: text("type").notNull(),
+    // Implementation type: 'keychain', 'nango', 'memory', etc.
+    credentialStoreId: text("credential_store_id").notNull(),
+    // Maps to framework.getCredentialStore(id)
+    retrievalParams: blob("retrieval_params", { mode: "json" }).$type(),
+    createdAt: text("created_at").notNull().default(sql`CURRENT_TIMESTAMP`),
+    updatedAt: text("updated_at").notNull().default(sql`CURRENT_TIMESTAMP`)
+  },
+  (t) => [primaryKey({ columns: [t.tenantId, t.projectId, t.id] })]
+);
+var ledgerArtifactsTaskIdIdx = index("ledger_artifacts_task_id_idx").on(
+  ledgerArtifacts.taskId
+);
+var ledgerArtifactsContextIdIdx = index("ledger_artifacts_context_id_idx").on(
+  ledgerArtifacts.contextId
+);
+var ledgerArtifactsTaskContextNameUnique = unique(
+  "ledger_artifacts_task_context_name_unique"
+).on(ledgerArtifacts.taskId, ledgerArtifacts.contextId, ledgerArtifacts.name);
+var tasksRelations = 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 = 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 = 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 = 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 = relations(contextCache, ({ one }) => ({
+  // Each cache entry belongs to one context config
+  contextConfig: one(contextConfigs, {
+    fields: [contextCache.contextConfigId],
+    references: [contextConfigs.id]
+  })
+}));
+var agentsRelations = 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 = 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 = 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 = 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 = 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 = relations(credentialReferences, ({ many }) => ({
+  tools: many(tools)
+}));
+var toolsRelations = 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 = 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 = 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 = relations(artifactComponents, ({ many }) => ({
+  // An artifact component can be associated with many agents
+  agentRelations: many(agentArtifactComponents)
+}));
+var agentArtifactComponentsRelations = 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 = 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]
+  })
+}));
+
+export { agentArtifactComponents, agentArtifactComponentsRelations, agentDataComponents, agentGraph, agentGraphRelations, agentRelations, agentRelationsRelations, agentToolRelations, agentToolRelationsRelations, agents, agentsRelations, apiKeys, apiKeysRelations, artifactComponents, artifactComponentsRelations, contextCache, contextCacheRelations, contextConfigs, contextConfigsRelations, conversations, conversationsRelations, credentialReferences, credentialReferencesRelations, dataComponents, externalAgents, externalAgentsRelations, ledgerArtifacts, ledgerArtifactsContextIdIdx, ledgerArtifactsTaskContextNameUnique, ledgerArtifactsTaskIdIdx, messages, messagesRelations, projects, projectsRelations, schema_exports, taskRelations, taskRelationsRelations, tasks, tasksRelations, tools, toolsRelations };