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

package/dist/db/schema.cjs

@@ -0,0 +1,1686 @@
+'use strict';
+
+var drizzleOrm = require('drizzle-orm');
+var pgCore = require('drizzle-orm/pg-core');
+
+// src/db/schema.ts
+var tenantScoped = {
+  tenantId: pgCore.varchar("tenant_id", { length: 256 }).notNull(),
+  id: pgCore.varchar("id", { length: 256 }).notNull()
+};
+var projectScoped = {
+  ...tenantScoped,
+  projectId: pgCore.varchar("project_id", { length: 256 }).notNull()
+};
+var agentScoped = {
+  ...projectScoped,
+  agentId: pgCore.varchar("agent_id", { length: 256 }).notNull()
+};
+var subAgentScoped = {
+  ...agentScoped,
+  subAgentId: pgCore.varchar("sub_agent_id", { length: 256 }).notNull()
+};
+var uiProperties = {
+  name: pgCore.varchar("name", { length: 256 }).notNull(),
+  description: pgCore.text("description").notNull()
+};
+var timestamps = {
+  createdAt: pgCore.timestamp("created_at", { mode: "string" }).notNull().defaultNow(),
+  updatedAt: pgCore.timestamp("updated_at", { mode: "string" }).notNull().defaultNow()
+};
+var projects = pgCore.pgTable(
+  "projects",
+  {
+    ...tenantScoped,
+    ...uiProperties,
+    models: pgCore.jsonb("models").$type(),
+    stopWhen: pgCore.jsonb("stop_when").$type(),
+    ...timestamps
+  },
+  (table) => [pgCore.primaryKey({ columns: [table.tenantId, table.id] })]
+);
+var agents = pgCore.pgTable(
+  "agent",
+  {
+    ...projectScoped,
+    name: pgCore.varchar("name", { length: 256 }).notNull(),
+    description: pgCore.text("description"),
+    defaultSubAgentId: pgCore.varchar("default_sub_agent_id", { length: 256 }),
+    contextConfigId: pgCore.varchar("context_config_id", { length: 256 }),
+    models: pgCore.jsonb("models").$type(),
+    statusUpdates: pgCore.jsonb("status_updates").$type(),
+    prompt: pgCore.text("prompt"),
+    stopWhen: pgCore.jsonb("stop_when").$type(),
+    ...timestamps
+  },
+  (table) => [
+    pgCore.primaryKey({ columns: [table.tenantId, table.projectId, table.id] }),
+    pgCore.foreignKey({
+      columns: [table.tenantId, table.projectId],
+      foreignColumns: [projects.tenantId, projects.id],
+      name: "agent_project_fk"
+    }).onDelete("cascade")
+  ]
+);
+var contextConfigs = pgCore.pgTable(
+  "context_configs",
+  {
+    ...agentScoped,
+    headersSchema: pgCore.jsonb("headers_schema").$type(),
+    contextVariables: pgCore.jsonb("context_variables").$type(),
+    ...timestamps
+  },
+  (table) => [
+    pgCore.primaryKey({ columns: [table.tenantId, table.projectId, table.agentId, table.id] }),
+    pgCore.foreignKey({
+      columns: [table.tenantId, table.projectId, table.agentId],
+      foreignColumns: [agents.tenantId, agents.projectId, agents.id],
+      name: "context_configs_agent_fk"
+    }).onDelete("cascade")
+  ]
+);
+var contextCache = pgCore.pgTable(
+  "context_cache",
+  {
+    ...projectScoped,
+    conversationId: pgCore.varchar("conversation_id", { length: 256 }).notNull(),
+    contextConfigId: pgCore.varchar("context_config_id", { length: 256 }).notNull(),
+    contextVariableKey: pgCore.varchar("context_variable_key", { length: 256 }).notNull(),
+    value: pgCore.jsonb("value").$type().notNull(),
+    requestHash: pgCore.varchar("request_hash", { length: 256 }),
+    fetchedAt: pgCore.timestamp("fetched_at", { mode: "string" }).notNull().defaultNow(),
+    fetchSource: pgCore.varchar("fetch_source", { length: 256 }),
+    fetchDurationMs: pgCore.integer("fetch_duration_ms"),
+    ...timestamps
+  },
+  (table) => [
+    pgCore.primaryKey({ columns: [table.tenantId, table.projectId, table.id] }),
+    pgCore.foreignKey({
+      columns: [table.tenantId, table.projectId],
+      foreignColumns: [projects.tenantId, projects.id],
+      name: "context_cache_project_fk"
+    }).onDelete("cascade"),
+    pgCore.index("context_cache_lookup_idx").on(
+      table.conversationId,
+      table.contextConfigId,
+      table.contextVariableKey
+    )
+  ]
+);
+var subAgents = pgCore.pgTable(
+  "sub_agents",
+  {
+    ...agentScoped,
+    ...uiProperties,
+    prompt: pgCore.text("prompt").notNull(),
+    conversationHistoryConfig: pgCore.jsonb("conversation_history_config").$type().default({
+      mode: "full",
+      limit: 50,
+      maxOutputTokens: 4e3,
+      includeInternal: false,
+      messageTypes: ["chat", "tool-result"]
+    }),
+    models: pgCore.jsonb("models").$type(),
+    stopWhen: pgCore.jsonb("stop_when").$type(),
+    ...timestamps
+  },
+  (table) => [
+    pgCore.primaryKey({ columns: [table.tenantId, table.projectId, table.agentId, table.id] }),
+    pgCore.foreignKey({
+      columns: [table.tenantId, table.projectId, table.agentId],
+      foreignColumns: [agents.tenantId, agents.projectId, agents.id],
+      name: "sub_agents_agents_fk"
+    }).onDelete("cascade")
+  ]
+);
+var subAgentRelations = pgCore.pgTable(
+  "sub_agent_relations",
+  {
+    ...agentScoped,
+    sourceSubAgentId: pgCore.varchar("source_sub_agent_id", { length: 256 }).notNull(),
+    targetSubAgentId: pgCore.varchar("target_sub_agent_id", { length: 256 }),
+    relationType: pgCore.varchar("relation_type", { length: 256 }),
+    ...timestamps
+  },
+  (table) => [
+    pgCore.primaryKey({ columns: [table.tenantId, table.projectId, table.agentId, table.id] }),
+    pgCore.foreignKey({
+      columns: [table.tenantId, table.projectId, table.agentId],
+      foreignColumns: [agents.tenantId, agents.projectId, agents.id],
+      name: "sub_agent_relations_agent_fk"
+    }).onDelete("cascade")
+  ]
+);
+var externalAgents = pgCore.pgTable(
+  "external_agents",
+  {
+    ...projectScoped,
+    ...uiProperties,
+    baseUrl: pgCore.text("base_url").notNull(),
+    credentialReferenceId: pgCore.varchar("credential_reference_id", { length: 256 }),
+    ...timestamps
+  },
+  (table) => [
+    pgCore.primaryKey({ columns: [table.tenantId, table.projectId, table.id] }),
+    pgCore.foreignKey({
+      columns: [table.tenantId, table.projectId],
+      foreignColumns: [projects.tenantId, projects.id],
+      name: "external_agents_project_fk"
+    }).onDelete("cascade"),
+    pgCore.foreignKey({
+      columns: [table.tenantId, table.projectId, table.credentialReferenceId],
+      foreignColumns: [
+        credentialReferences.tenantId,
+        credentialReferences.projectId,
+        credentialReferences.id
+      ],
+      name: "external_agents_credential_reference_fk"
+    }).onDelete("cascade")
+  ]
+);
+var tasks = pgCore.pgTable(
+  "tasks",
+  {
+    ...subAgentScoped,
+    contextId: pgCore.varchar("context_id", { length: 256 }).notNull(),
+    status: pgCore.varchar("status", { length: 256 }).notNull(),
+    metadata: pgCore.jsonb("metadata").$type(),
+    ...timestamps
+  },
+  (table) => [
+    pgCore.primaryKey({ columns: [table.tenantId, table.projectId, table.id] }),
+    pgCore.foreignKey({
+      columns: [table.tenantId, table.projectId, table.agentId, table.subAgentId],
+      foreignColumns: [subAgents.tenantId, subAgents.projectId, subAgents.agentId, subAgents.id],
+      name: "tasks_sub_agent_fk"
+    }).onDelete("cascade")
+  ]
+);
+var taskRelations = pgCore.pgTable(
+  "task_relations",
+  {
+    ...projectScoped,
+    parentTaskId: pgCore.varchar("parent_task_id", { length: 256 }).notNull(),
+    childTaskId: pgCore.varchar("child_task_id", { length: 256 }).notNull(),
+    relationType: pgCore.varchar("relation_type", { length: 256 }).default("parent_child"),
+    ...timestamps
+  },
+  (table) => [
+    pgCore.primaryKey({ columns: [table.tenantId, table.projectId, table.id] }),
+    pgCore.foreignKey({
+      columns: [table.tenantId, table.projectId],
+      foreignColumns: [projects.tenantId, projects.id],
+      name: "task_relations_project_fk"
+    }).onDelete("cascade")
+  ]
+);
+var dataComponents = pgCore.pgTable(
+  "data_components",
+  {
+    ...projectScoped,
+    ...uiProperties,
+    props: pgCore.jsonb("props").$type(),
+    render: pgCore.jsonb("render").$type(),
+    ...timestamps
+  },
+  (table) => [
+    pgCore.primaryKey({ columns: [table.tenantId, table.projectId, table.id] }),
+    pgCore.foreignKey({
+      columns: [table.tenantId, table.projectId],
+      foreignColumns: [projects.tenantId, projects.id],
+      name: "data_components_project_fk"
+    }).onDelete("cascade")
+  ]
+);
+var subAgentDataComponents = pgCore.pgTable(
+  "sub_agent_data_components",
+  {
+    ...subAgentScoped,
+    dataComponentId: pgCore.varchar("data_component_id", { length: 256 }).notNull(),
+    createdAt: pgCore.timestamp("created_at", { mode: "string" }).notNull().defaultNow()
+  },
+  (table) => [
+    pgCore.primaryKey({ columns: [table.tenantId, table.projectId, table.id] }),
+    pgCore.foreignKey({
+      columns: [table.tenantId, table.projectId, table.agentId, table.subAgentId],
+      foreignColumns: [subAgents.tenantId, subAgents.projectId, subAgents.agentId, subAgents.id],
+      name: "sub_agent_data_components_sub_agent_fk"
+    }).onDelete("cascade"),
+    pgCore.foreignKey({
+      columns: [table.tenantId, table.projectId, table.dataComponentId],
+      foreignColumns: [dataComponents.tenantId, dataComponents.projectId, dataComponents.id],
+      name: "sub_agent_data_components_data_component_fk"
+    }).onDelete("cascade")
+  ]
+);
+var artifactComponents = pgCore.pgTable(
+  "artifact_components",
+  {
+    ...projectScoped,
+    ...uiProperties,
+    props: pgCore.jsonb("props").$type(),
+    ...timestamps
+  },
+  (table) => [
+    pgCore.primaryKey({ columns: [table.tenantId, table.projectId, table.id] }),
+    pgCore.foreignKey({
+      columns: [table.tenantId, table.projectId],
+      foreignColumns: [projects.tenantId, projects.id],
+      name: "artifact_components_project_fk"
+    }).onDelete("cascade")
+  ]
+);
+var subAgentArtifactComponents = pgCore.pgTable(
+  "sub_agent_artifact_components",
+  {
+    ...subAgentScoped,
+    artifactComponentId: pgCore.varchar("artifact_component_id", { length: 256 }).notNull(),
+    createdAt: pgCore.timestamp("created_at", { mode: "string" }).notNull().defaultNow()
+  },
+  (table) => [
+    pgCore.primaryKey({
+      columns: [table.tenantId, table.projectId, table.agentId, table.subAgentId, table.id]
+    }),
+    pgCore.foreignKey({
+      columns: [table.tenantId, table.projectId, table.agentId, table.subAgentId],
+      foreignColumns: [subAgents.tenantId, subAgents.projectId, subAgents.agentId, subAgents.id],
+      name: "sub_agent_artifact_components_sub_agent_fk"
+    }).onDelete("cascade"),
+    pgCore.foreignKey({
+      columns: [table.tenantId, table.projectId, table.artifactComponentId],
+      foreignColumns: [
+        artifactComponents.tenantId,
+        artifactComponents.projectId,
+        artifactComponents.id
+      ],
+      name: "sub_agent_artifact_components_artifact_component_fk"
+    }).onDelete("cascade")
+  ]
+);
+var tools = pgCore.pgTable(
+  "tools",
+  {
+    ...projectScoped,
+    name: pgCore.varchar("name", { length: 256 }).notNull(),
+    description: pgCore.text("description"),
+    config: pgCore.jsonb("config").$type().notNull(),
+    credentialReferenceId: pgCore.varchar("credential_reference_id", { length: 256 }),
+    headers: pgCore.jsonb("headers").$type(),
+    imageUrl: pgCore.text("image_url"),
+    capabilities: pgCore.jsonb("capabilities").$type(),
+    lastError: pgCore.text("last_error"),
+    ...timestamps
+  },
+  (table) => [
+    pgCore.primaryKey({ columns: [table.tenantId, table.projectId, table.id] }),
+    pgCore.foreignKey({
+      columns: [table.tenantId, table.projectId],
+      foreignColumns: [projects.tenantId, projects.id],
+      name: "tools_project_fk"
+    }).onDelete("cascade")
+  ]
+);
+var functionTools = pgCore.pgTable(
+  "function_tools",
+  {
+    ...agentScoped,
+    name: pgCore.varchar("name", { length: 256 }).notNull(),
+    description: pgCore.text("description"),
+    functionId: pgCore.varchar("function_id", { length: 256 }).notNull(),
+    ...timestamps
+  },
+  (table) => [
+    pgCore.primaryKey({ columns: [table.tenantId, table.projectId, table.agentId, table.id] }),
+    pgCore.foreignKey({
+      columns: [table.tenantId, table.projectId, table.agentId],
+      foreignColumns: [agents.tenantId, agents.projectId, agents.id],
+      name: "function_tools_agent_fk"
+    }).onDelete("cascade"),
+    pgCore.foreignKey({
+      columns: [table.tenantId, table.projectId, table.functionId],
+      foreignColumns: [functions.tenantId, functions.projectId, functions.id],
+      name: "function_tools_function_fk"
+    }).onDelete("cascade")
+  ]
+);
+var functions = pgCore.pgTable(
+  "functions",
+  {
+    ...projectScoped,
+    inputSchema: pgCore.jsonb("input_schema").$type(),
+    executeCode: pgCore.text("execute_code").notNull(),
+    dependencies: pgCore.jsonb("dependencies").$type(),
+    ...timestamps
+  },
+  (table) => [
+    pgCore.primaryKey({ columns: [table.tenantId, table.projectId, table.id] }),
+    pgCore.foreignKey({
+      columns: [table.tenantId, table.projectId],
+      foreignColumns: [projects.tenantId, projects.id],
+      name: "functions_project_fk"
+    }).onDelete("cascade")
+  ]
+);
+var subAgentToolRelations = pgCore.pgTable(
+  "sub_agent_tool_relations",
+  {
+    ...subAgentScoped,
+    toolId: pgCore.varchar("tool_id", { length: 256 }).notNull(),
+    selectedTools: pgCore.jsonb("selected_tools").$type(),
+    headers: pgCore.jsonb("headers").$type(),
+    toolPolicies: pgCore.jsonb("tool_policies").$type(),
+    ...timestamps
+  },
+  (table) => [
+    pgCore.primaryKey({ columns: [table.tenantId, table.projectId, table.agentId, table.id] }),
+    pgCore.foreignKey({
+      columns: [table.tenantId, table.projectId, table.agentId, table.subAgentId],
+      foreignColumns: [subAgents.tenantId, subAgents.projectId, subAgents.agentId, subAgents.id],
+      name: "sub_agent_tool_relations_agent_fk"
+    }).onDelete("cascade"),
+    pgCore.foreignKey({
+      columns: [table.tenantId, table.projectId, table.toolId],
+      foreignColumns: [tools.tenantId, tools.projectId, tools.id],
+      name: "sub_agent_tool_relations_tool_fk"
+    }).onDelete("cascade")
+  ]
+);
+var subAgentExternalAgentRelations = pgCore.pgTable(
+  "sub_agent_external_agent_relations",
+  {
+    ...subAgentScoped,
+    externalAgentId: pgCore.varchar("external_agent_id", { length: 256 }).notNull(),
+    headers: pgCore.jsonb("headers").$type(),
+    ...timestamps
+  },
+  (table) => [
+    pgCore.primaryKey({ columns: [table.tenantId, table.projectId, table.agentId, table.id] }),
+    pgCore.foreignKey({
+      columns: [table.tenantId, table.projectId, table.agentId, table.subAgentId],
+      foreignColumns: [subAgents.tenantId, subAgents.projectId, subAgents.agentId, subAgents.id],
+      name: "sub_agent_external_agent_relations_sub_agent_fk"
+    }).onDelete("cascade"),
+    pgCore.foreignKey({
+      columns: [table.tenantId, table.projectId, table.externalAgentId],
+      foreignColumns: [externalAgents.tenantId, externalAgents.projectId, externalAgents.id],
+      name: "sub_agent_external_agent_relations_external_agent_fk"
+    }).onDelete("cascade")
+  ]
+);
+var subAgentTeamAgentRelations = pgCore.pgTable(
+  "sub_agent_team_agent_relations",
+  {
+    ...subAgentScoped,
+    targetAgentId: pgCore.varchar("target_agent_id", { length: 256 }).notNull(),
+    headers: pgCore.jsonb("headers").$type(),
+    ...timestamps
+  },
+  (table) => [
+    pgCore.primaryKey({ columns: [table.tenantId, table.projectId, table.agentId, table.id] }),
+    pgCore.foreignKey({
+      columns: [table.tenantId, table.projectId, table.agentId, table.subAgentId],
+      foreignColumns: [subAgents.tenantId, subAgents.projectId, subAgents.agentId, subAgents.id],
+      name: "sub_agent_team_agent_relations_sub_agent_fk"
+    }).onDelete("cascade"),
+    pgCore.foreignKey({
+      columns: [table.tenantId, table.projectId, table.targetAgentId],
+      foreignColumns: [agents.tenantId, agents.projectId, agents.id],
+      name: "sub_agent_team_agent_relations_target_agent_fk"
+    }).onDelete("cascade")
+  ]
+);
+var subAgentFunctionToolRelations = pgCore.pgTable(
+  "sub_agent_function_tool_relations",
+  {
+    ...subAgentScoped,
+    functionToolId: pgCore.varchar("function_tool_id", { length: 256 }).notNull(),
+    ...timestamps
+  },
+  (table) => [
+    pgCore.primaryKey({ columns: [table.tenantId, table.projectId, table.agentId, table.id] }),
+    pgCore.foreignKey({
+      columns: [table.tenantId, table.projectId, table.agentId, table.subAgentId],
+      foreignColumns: [subAgents.tenantId, subAgents.projectId, subAgents.agentId, subAgents.id],
+      name: "sub_agent_function_tool_relations_sub_agent_fk"
+    }).onDelete("cascade"),
+    pgCore.foreignKey({
+      columns: [table.tenantId, table.projectId, table.agentId, table.functionToolId],
+      foreignColumns: [
+        functionTools.tenantId,
+        functionTools.projectId,
+        functionTools.agentId,
+        functionTools.id
+      ],
+      name: "sub_agent_function_tool_relations_function_tool_fk"
+    }).onDelete("cascade")
+  ]
+);
+var conversations = pgCore.pgTable(
+  "conversations",
+  {
+    ...projectScoped,
+    userId: pgCore.varchar("user_id", { length: 256 }),
+    activeSubAgentId: pgCore.varchar("active_sub_agent_id", { length: 256 }).notNull(),
+    title: pgCore.text("title"),
+    lastContextResolution: pgCore.timestamp("last_context_resolution", { mode: "string" }),
+    metadata: pgCore.jsonb("metadata").$type(),
+    ...timestamps
+  },
+  (table) => [
+    pgCore.primaryKey({ columns: [table.tenantId, table.projectId, table.id] }),
+    pgCore.foreignKey({
+      columns: [table.tenantId, table.projectId],
+      foreignColumns: [projects.tenantId, projects.id],
+      name: "conversations_project_fk"
+    }).onDelete("cascade")
+  ]
+);
+var messages = pgCore.pgTable(
+  "messages",
+  {
+    ...projectScoped,
+    conversationId: pgCore.varchar("conversation_id", { length: 256 }).notNull(),
+    role: pgCore.varchar("role", { length: 256 }).notNull(),
+    fromSubAgentId: pgCore.varchar("from_sub_agent_id", { length: 256 }),
+    toSubAgentId: pgCore.varchar("to_sub_agent_id", { length: 256 }),
+    fromExternalAgentId: pgCore.varchar("from_external_sub_agent_id", { length: 256 }),
+    toExternalAgentId: pgCore.varchar("to_external_sub_agent_id", { length: 256 }),
+    fromTeamAgentId: pgCore.varchar("from_team_agent_id", { length: 256 }),
+    toTeamAgentId: pgCore.varchar("to_team_agent_id", { length: 256 }),
+    content: pgCore.jsonb("content").$type().notNull(),
+    visibility: pgCore.varchar("visibility", { length: 256 }).notNull().default("user-facing"),
+    messageType: pgCore.varchar("message_type", { length: 256 }).notNull().default("chat"),
+    taskId: pgCore.varchar("task_id", { length: 256 }),
+    parentMessageId: pgCore.varchar("parent_message_id", { length: 256 }),
+    a2aTaskId: pgCore.varchar("a2a_task_id", { length: 256 }),
+    a2aSessionId: pgCore.varchar("a2a_session_id", { length: 256 }),
+    metadata: pgCore.jsonb("metadata").$type(),
+    ...timestamps
+  },
+  (table) => [
+    pgCore.primaryKey({ columns: [table.tenantId, table.projectId, table.id] }),
+    pgCore.foreignKey({
+      columns: [table.tenantId, table.projectId],
+      foreignColumns: [projects.tenantId, projects.id],
+      name: "messages_project_fk"
+    }).onDelete("cascade")
+  ]
+);
+var ledgerArtifacts = pgCore.pgTable(
+  "ledger_artifacts",
+  {
+    ...projectScoped,
+    taskId: pgCore.varchar("task_id", { length: 256 }).notNull(),
+    toolCallId: pgCore.varchar("tool_call_id", { length: 256 }),
+    contextId: pgCore.varchar("context_id", { length: 256 }).notNull(),
+    type: pgCore.varchar("type", { length: 256 }).notNull().default("source"),
+    name: pgCore.varchar("name", { length: 256 }),
+    description: pgCore.text("description"),
+    parts: pgCore.jsonb("parts").$type(),
+    metadata: pgCore.jsonb("metadata").$type(),
+    summary: pgCore.text("summary"),
+    mime: pgCore.jsonb("mime").$type(),
+    visibility: pgCore.varchar("visibility", { length: 256 }).default("context"),
+    allowedAgents: pgCore.jsonb("allowed_agents").$type(),
+    derivedFrom: pgCore.varchar("derived_from", { length: 256 }),
+    ...timestamps
+  },
+  (table) => [
+    pgCore.primaryKey({ columns: [table.tenantId, table.projectId, table.id, table.taskId] }),
+    pgCore.foreignKey({
+      columns: [table.tenantId, table.projectId],
+      foreignColumns: [projects.tenantId, projects.id],
+      name: "ledger_artifacts_project_fk"
+    }).onDelete("cascade"),
+    pgCore.index("ledger_artifacts_task_id_idx").on(table.taskId),
+    pgCore.index("ledger_artifacts_tool_call_id_idx").on(table.toolCallId),
+    pgCore.index("ledger_artifacts_context_id_idx").on(table.contextId),
+    pgCore.unique("ledger_artifacts_task_context_name_unique").on(
+      table.taskId,
+      table.contextId,
+      table.name
+    )
+  ]
+);
+var apiKeys = pgCore.pgTable(
+  "api_keys",
+  {
+    ...agentScoped,
+    publicId: pgCore.varchar("public_id", { length: 256 }).notNull().unique(),
+    keyHash: pgCore.varchar("key_hash", { length: 256 }).notNull(),
+    keyPrefix: pgCore.varchar("key_prefix", { length: 256 }).notNull(),
+    name: pgCore.varchar("name", { length: 256 }),
+    lastUsedAt: pgCore.timestamp("last_used_at", { mode: "string" }),
+    expiresAt: pgCore.timestamp("expires_at", { mode: "string" }),
+    ...timestamps
+  },
+  (t) => [
+    pgCore.foreignKey({
+      columns: [t.tenantId, t.projectId],
+      foreignColumns: [projects.tenantId, projects.id],
+      name: "api_keys_project_fk"
+    }).onDelete("cascade"),
+    pgCore.foreignKey({
+      columns: [t.tenantId, t.projectId, t.agentId],
+      foreignColumns: [agents.tenantId, agents.projectId, agents.id],
+      name: "api_keys_agent_fk"
+    }).onDelete("cascade"),
+    pgCore.index("api_keys_tenant_agent_idx").on(t.tenantId, t.agentId),
+    pgCore.index("api_keys_prefix_idx").on(t.keyPrefix),
+    pgCore.index("api_keys_public_id_idx").on(t.publicId)
+  ]
+);
+var credentialReferences = pgCore.pgTable(
+  "credential_references",
+  {
+    ...projectScoped,
+    name: pgCore.varchar("name", { length: 256 }).notNull(),
+    type: pgCore.varchar("type", { length: 256 }).notNull(),
+    credentialStoreId: pgCore.varchar("credential_store_id", { length: 256 }).notNull(),
+    retrievalParams: pgCore.jsonb("retrieval_params").$type(),
+    ...timestamps
+  },
+  (t) => [
+    pgCore.primaryKey({ columns: [t.tenantId, t.projectId, t.id] }),
+    pgCore.foreignKey({
+      columns: [t.tenantId, t.projectId],
+      foreignColumns: [projects.tenantId, projects.id],
+      name: "credential_references_project_fk"
+    }).onDelete("cascade")
+  ]
+);
+var dataset = pgCore.pgTable(
+  "dataset",
+  {
+    ...projectScoped,
+    ...uiProperties,
+    ...timestamps
+  },
+  (table) => [
+    pgCore.primaryKey({ columns: [table.tenantId, table.projectId, table.id] }),
+    pgCore.foreignKey({
+      columns: [table.tenantId, table.projectId],
+      foreignColumns: [projects.tenantId, projects.id],
+      name: "dataset_project_fk"
+    }).onDelete("cascade")
+  ]
+);
+var datasetItem = pgCore.pgTable(
+  "dataset_item",
+  {
+    ...projectScoped,
+    datasetId: pgCore.text("dataset_id").notNull(),
+    input: pgCore.jsonb("input").$type().notNull(),
+    expectedOutput: pgCore.jsonb("expected_output").$type(),
+    simulationAgent: pgCore.jsonb("simulation_agent").$type(),
+    ...timestamps
+  },
+  (table) => [
+    pgCore.primaryKey({ columns: [table.tenantId, table.projectId, table.id] }),
+    pgCore.foreignKey({
+      columns: [table.tenantId, table.projectId, table.datasetId],
+      foreignColumns: [dataset.tenantId, dataset.projectId, dataset.id],
+      name: "dataset_item_dataset_fk"
+    }).onDelete("cascade")
+  ]
+);
+var evaluator = pgCore.pgTable(
+  "evaluator",
+  {
+    ...projectScoped,
+    ...uiProperties,
+    prompt: pgCore.text("prompt").notNull(),
+    schema: pgCore.jsonb("schema").$type().notNull(),
+    model: pgCore.jsonb("model").$type().notNull(),
+    passCriteria: pgCore.jsonb("pass_criteria").$type(),
+    ...timestamps
+  },
+  (table) => [
+    pgCore.primaryKey({ columns: [table.tenantId, table.projectId, table.id] }),
+    pgCore.foreignKey({
+      columns: [table.tenantId, table.projectId],
+      foreignColumns: [projects.tenantId, projects.id],
+      name: "evaluator_project_fk"
+    }).onDelete("cascade")
+  ]
+);
+var datasetRunConfig = pgCore.pgTable(
+  "dataset_run_config",
+  {
+    ...projectScoped,
+    ...uiProperties,
+    datasetId: pgCore.text("dataset_id").notNull(),
+    ...timestamps
+  },
+  (table) => [
+    pgCore.primaryKey({ columns: [table.tenantId, table.projectId, table.id] }),
+    pgCore.foreignKey({
+      columns: [table.tenantId, table.projectId],
+      foreignColumns: [projects.tenantId, projects.id],
+      name: "dataset_run_config_project_fk"
+    }).onDelete("cascade"),
+    pgCore.foreignKey({
+      columns: [table.tenantId, table.projectId, table.datasetId],
+      foreignColumns: [dataset.tenantId, dataset.projectId, dataset.id],
+      name: "dataset_run_config_dataset_fk"
+    }).onDelete("cascade")
+  ]
+);
+var datasetRunConfigAgentRelations = pgCore.pgTable(
+  "dataset_run_config_agent_relations",
+  {
+    ...projectScoped,
+    datasetRunConfigId: pgCore.text("dataset_run_config_id").notNull(),
+    agentId: pgCore.text("agent_id").notNull(),
+    ...timestamps
+  },
+  (table) => [
+    pgCore.primaryKey({ columns: [table.tenantId, table.projectId, table.id] }),
+    pgCore.foreignKey({
+      columns: [table.tenantId, table.projectId, table.datasetRunConfigId],
+      foreignColumns: [datasetRunConfig.tenantId, datasetRunConfig.projectId, datasetRunConfig.id],
+      name: "dataset_run_config_agent_relations_dataset_run_config_fk"
+    }).onDelete("cascade"),
+    pgCore.foreignKey({
+      columns: [table.tenantId, table.projectId, table.agentId],
+      foreignColumns: [agents.tenantId, agents.projectId, agents.id],
+      name: "dataset_run_config_agent_relations_agent_fk"
+    }).onDelete("cascade")
+  ]
+);
+var datasetRunConfigEvaluationRunConfigRelations = pgCore.pgTable(
+  "dataset_run_config_evaluation_run_config_relations",
+  {
+    ...projectScoped,
+    datasetRunConfigId: pgCore.text("dataset_run_config_id").notNull(),
+    evaluationRunConfigId: pgCore.text("evaluation_run_config_id").notNull(),
+    enabled: pgCore.boolean("enabled").notNull().default(true),
+    ...timestamps
+  },
+  (table) => [
+    pgCore.primaryKey({ columns: [table.tenantId, table.projectId, table.id] }),
+    pgCore.foreignKey({
+      columns: [table.tenantId, table.projectId, table.datasetRunConfigId],
+      foreignColumns: [datasetRunConfig.tenantId, datasetRunConfig.projectId, datasetRunConfig.id],
+      name: "dataset_run_config_evaluation_run_config_relations_dataset_run_config_fk"
+    }).onDelete("cascade"),
+    pgCore.foreignKey({
+      columns: [table.tenantId, table.projectId, table.evaluationRunConfigId],
+      foreignColumns: [
+        evaluationRunConfig.tenantId,
+        evaluationRunConfig.projectId,
+        evaluationRunConfig.id
+      ],
+      name: "dataset_run_config_evaluation_run_config_relations_evaluation_run_config_fk"
+    }).onDelete("cascade")
+  ]
+);
+var datasetRun = pgCore.pgTable(
+  "dataset_run",
+  {
+    ...projectScoped,
+    datasetId: pgCore.text("dataset_id").notNull(),
+    datasetRunConfigId: pgCore.text("dataset_run_config_id").notNull(),
+    evaluationJobConfigId: pgCore.text("evaluation_job_config_id"),
+    ...timestamps
+  },
+  (table) => [
+    pgCore.primaryKey({ columns: [table.tenantId, table.projectId, table.id] }),
+    pgCore.foreignKey({
+      columns: [table.tenantId, table.projectId, table.datasetId],
+      foreignColumns: [dataset.tenantId, dataset.projectId, dataset.id],
+      name: "dataset_run_dataset_fk"
+    }).onDelete("cascade"),
+    pgCore.foreignKey({
+      columns: [table.tenantId, table.projectId, table.datasetRunConfigId],
+      foreignColumns: [datasetRunConfig.tenantId, datasetRunConfig.projectId, datasetRunConfig.id],
+      name: "dataset_run_dataset_run_config_fk"
+    }).onDelete("cascade"),
+    pgCore.foreignKey({
+      columns: [table.tenantId, table.projectId, table.evaluationJobConfigId],
+      foreignColumns: [
+        evaluationJobConfig.tenantId,
+        evaluationJobConfig.projectId,
+        evaluationJobConfig.id
+      ],
+      name: "dataset_run_evaluation_job_config_fk"
+    }).onDelete("set null")
+  ]
+);
+var datasetRunConversationRelations = pgCore.pgTable(
+  "dataset_run_conversation_relations",
+  {
+    ...projectScoped,
+    datasetRunId: pgCore.text("dataset_run_id").notNull(),
+    conversationId: pgCore.text("conversation_id").notNull(),
+    datasetItemId: pgCore.text("dataset_item_id").notNull(),
+    ...timestamps
+  },
+  (table) => [
+    pgCore.primaryKey({ columns: [table.tenantId, table.projectId, table.id] }),
+    pgCore.foreignKey({
+      columns: [table.tenantId, table.projectId, table.datasetRunId],
+      foreignColumns: [datasetRun.tenantId, datasetRun.projectId, datasetRun.id],
+      name: "dataset_run_conversation_relations_run_fk"
+    }).onDelete("cascade"),
+    pgCore.foreignKey({
+      columns: [table.tenantId, table.projectId, table.conversationId],
+      foreignColumns: [conversations.tenantId, conversations.projectId, conversations.id],
+      name: "dataset_run_conversation_relations_conversation_fk"
+    }).onDelete("cascade"),
+    pgCore.foreignKey({
+      columns: [table.tenantId, table.projectId, table.datasetItemId],
+      foreignColumns: [datasetItem.tenantId, datasetItem.projectId, datasetItem.id],
+      name: "dataset_run_conversation_relations_item_fk"
+    }).onDelete("cascade"),
+    pgCore.unique("dataset_run_conversation_relations_unique").on(
+      table.datasetRunId,
+      table.conversationId
+    )
+  ]
+);
+var evaluationSuiteConfig = pgCore.pgTable(
+  "evaluation_suite_config",
+  {
+    ...projectScoped,
+    ...uiProperties,
+    filters: pgCore.jsonb("filters").$type(),
+    // Filters for the evaluation suite (supports and/or operations)
+    sampleRate: pgCore.doublePrecision("sample_rate"),
+    ...timestamps
+  },
+  (table) => [
+    pgCore.primaryKey({ columns: [table.tenantId, table.projectId, table.id] }),
+    pgCore.foreignKey({
+      columns: [table.tenantId, table.projectId],
+      foreignColumns: [projects.tenantId, projects.id],
+      name: "evaluation_suite_config_project_fk"
+    }).onDelete("cascade")
+  ]
+);
+var evaluationSuiteConfigEvaluatorRelations = pgCore.pgTable(
+  "evaluation_suite_config_evaluator_relations",
+  {
+    ...projectScoped,
+    evaluationSuiteConfigId: pgCore.text("evaluation_suite_config_id").notNull(),
+    evaluatorId: pgCore.text("evaluator_id").notNull(),
+    ...timestamps
+  },
+  (table) => [
+    pgCore.primaryKey({ columns: [table.tenantId, table.projectId, table.id] }),
+    pgCore.foreignKey({
+      columns: [table.tenantId, table.projectId, table.evaluationSuiteConfigId],
+      foreignColumns: [
+        evaluationSuiteConfig.tenantId,
+        evaluationSuiteConfig.projectId,
+        evaluationSuiteConfig.id
+      ],
+      name: "evaluation_suite_config_evaluator_relations_evaluation_suite_config_fk"
+    }).onDelete("cascade"),
+    pgCore.foreignKey({
+      columns: [table.tenantId, table.projectId, table.evaluatorId],
+      foreignColumns: [evaluator.tenantId, evaluator.projectId, evaluator.id],
+      name: "evaluation_suite_config_evaluator_relations_evaluator_fk"
+    }).onDelete("cascade")
+  ]
+);
+var evaluationRunConfig = pgCore.pgTable(
+  "evaluation_run_config",
+  {
+    ...projectScoped,
+    ...uiProperties,
+    isActive: pgCore.boolean("is_active").notNull().default(true),
+    ...timestamps
+  },
+  (table) => [
+    pgCore.primaryKey({ columns: [table.tenantId, table.projectId, table.id] }),
+    pgCore.foreignKey({
+      columns: [table.tenantId, table.projectId],
+      foreignColumns: [projects.tenantId, projects.id],
+      name: "evaluation_run_config_project_fk"
+    }).onDelete("cascade")
+  ]
+);
+var evaluationRunConfigEvaluationSuiteConfigRelations = pgCore.pgTable(
+  "evaluation_run_config_evaluation_suite_config_relations",
+  {
+    ...projectScoped,
+    evaluationRunConfigId: pgCore.text("evaluation_run_config_id").notNull(),
+    evaluationSuiteConfigId: pgCore.text("evaluation_suite_config_id").notNull(),
+    ...timestamps
+  },
+  (table) => [
+    pgCore.primaryKey({ columns: [table.tenantId, table.projectId, table.id] }),
+    pgCore.foreignKey({
+      columns: [table.tenantId, table.projectId, table.evaluationRunConfigId],
+      foreignColumns: [
+        evaluationRunConfig.tenantId,
+        evaluationRunConfig.projectId,
+        evaluationRunConfig.id
+      ],
+      name: "eval_run_config_eval_suite_rel_run_config_fk"
+    }).onDelete("cascade"),
+    pgCore.foreignKey({
+      columns: [table.tenantId, table.projectId, table.evaluationSuiteConfigId],
+      foreignColumns: [
+        evaluationSuiteConfig.tenantId,
+        evaluationSuiteConfig.projectId,
+        evaluationSuiteConfig.id
+      ],
+      name: "eval_run_config_eval_suite_rel_suite_config_fk"
+    }).onDelete("cascade")
+  ]
+);
+var evaluationJobConfig = pgCore.pgTable(
+  "evaluation_job_config",
+  {
+    ...projectScoped,
+    jobFilters: pgCore.jsonb("job_filters").$type(),
+    ...timestamps
+  },
+  (table) => [
+    pgCore.primaryKey({ columns: [table.tenantId, table.projectId, table.id] }),
+    pgCore.foreignKey({
+      columns: [table.tenantId, table.projectId],
+      foreignColumns: [projects.tenantId, projects.id],
+      name: "evaluation_job_config_project_fk"
+    }).onDelete("cascade")
+  ]
+);
+var evaluationJobConfigEvaluatorRelations = pgCore.pgTable(
+  "evaluation_job_config_evaluator_relations",
+  {
+    ...projectScoped,
+    evaluationJobConfigId: pgCore.text("evaluation_job_config_id").notNull(),
+    evaluatorId: pgCore.text("evaluator_id").notNull(),
+    ...timestamps
+  },
+  (table) => [
+    pgCore.primaryKey({ columns: [table.tenantId, table.projectId, table.id] }),
+    pgCore.foreignKey({
+      columns: [table.tenantId, table.projectId, table.evaluationJobConfigId],
+      foreignColumns: [
+        evaluationJobConfig.tenantId,
+        evaluationJobConfig.projectId,
+        evaluationJobConfig.id
+      ],
+      name: "evaluation_job_config_evaluator_relations_evaluation_job_config_fk"
+    }).onDelete("cascade"),
+    pgCore.foreignKey({
+      columns: [table.tenantId, table.projectId, table.evaluatorId],
+      foreignColumns: [evaluator.tenantId, evaluator.projectId, evaluator.id],
+      name: "evaluation_job_config_evaluator_relations_evaluator_fk"
+    }).onDelete("cascade")
+  ]
+);
+var evaluationRun = pgCore.pgTable(
+  "evaluation_run",
+  {
+    ...projectScoped,
+    evaluationJobConfigId: pgCore.text("evaluation_job_config_id"),
+    // Optional: if created from a job
+    evaluationRunConfigId: pgCore.text("evaluation_run_config_id"),
+    // Optional: if created from a run config
+    ...timestamps
+  },
+  (table) => [
+    pgCore.primaryKey({ columns: [table.tenantId, table.projectId, table.id] }),
+    pgCore.foreignKey({
+      columns: [table.tenantId, table.projectId, table.evaluationJobConfigId],
+      foreignColumns: [
+        evaluationJobConfig.tenantId,
+        evaluationJobConfig.projectId,
+        evaluationJobConfig.id
+      ],
+      name: "evaluation_run_evaluation_job_config_fk"
+    }).onDelete("cascade"),
+    pgCore.foreignKey({
+      columns: [table.tenantId, table.projectId, table.evaluationRunConfigId],
+      foreignColumns: [
+        evaluationRunConfig.tenantId,
+        evaluationRunConfig.projectId,
+        evaluationRunConfig.id
+      ],
+      name: "evaluation_run_evaluation_run_config_fk"
+    }).onDelete("cascade")
+  ]
+);
+var evaluationResult = pgCore.pgTable(
+  "evaluation_result",
+  {
+    ...projectScoped,
+    conversationId: pgCore.text("conversation_id").notNull(),
+    evaluatorId: pgCore.text("evaluator_id").notNull(),
+    evaluationRunId: pgCore.text("evaluation_run_id"),
+    output: pgCore.jsonb("output").$type(),
+    ...timestamps
+  },
+  (table) => [
+    pgCore.primaryKey({ columns: [table.tenantId, table.projectId, table.id] }),
+    pgCore.foreignKey({
+      columns: [table.tenantId, table.projectId, table.conversationId],
+      foreignColumns: [conversations.tenantId, conversations.projectId, conversations.id],
+      name: "evaluation_result_conversation_fk"
+    }).onDelete("cascade"),
+    pgCore.foreignKey({
+      columns: [table.tenantId, table.projectId, table.evaluatorId],
+      foreignColumns: [evaluator.tenantId, evaluator.projectId, evaluator.id],
+      name: "evaluation_result_evaluator_fk"
+    }).onDelete("cascade"),
+    pgCore.foreignKey({
+      columns: [table.tenantId, table.projectId, table.evaluationRunId],
+      foreignColumns: [evaluationRun.tenantId, evaluationRun.projectId, evaluationRun.id],
+      name: "evaluation_result_evaluation_run_fk"
+    }).onDelete("cascade")
+  ]
+);
+var tasksRelations = drizzleOrm.relations(tasks, ({ one, many }) => ({
+  project: one(projects, {
+    fields: [tasks.tenantId, tasks.projectId],
+    references: [projects.tenantId, projects.id]
+  }),
+  // A task can have many parent relationships (where it's the child)
+  parentRelations: many(taskRelations, {
+    relationName: "childTask"
+  }),
+  // A task can have many child relationships (where it's the parent)
+  childRelations: many(taskRelations, {
+    relationName: "parentTask"
+  }),
+  subAgent: one(subAgents, {
+    fields: [tasks.subAgentId],
+    references: [subAgents.id]
+  }),
+  messages: many(messages),
+  ledgerArtifacts: many(ledgerArtifacts)
+}));
+var projectsRelations = drizzleOrm.relations(projects, ({ many }) => ({
+  subAgents: many(subAgents),
+  agents: many(agents),
+  tools: many(tools),
+  functions: many(functions),
+  contextConfigs: many(contextConfigs),
+  externalAgents: many(externalAgents),
+  conversations: many(conversations),
+  tasks: many(tasks),
+  dataComponents: many(dataComponents),
+  artifactComponents: many(artifactComponents),
+  ledgerArtifacts: many(ledgerArtifacts),
+  credentialReferences: many(credentialReferences),
+  datasets: many(dataset),
+  evaluators: many(evaluator),
+  evaluationSuiteConfigs: many(evaluationSuiteConfig),
+  datasetRunConfigs: many(datasetRunConfig)
+}));
+var taskRelationsRelations = drizzleOrm.relations(taskRelations, ({ one }) => ({
+  parentTask: one(tasks, {
+    fields: [taskRelations.parentTaskId],
+    references: [tasks.id],
+    relationName: "parentTask"
+  }),
+  childTask: one(tasks, {
+    fields: [taskRelations.childTaskId],
+    references: [tasks.id],
+    relationName: "childTask"
+  })
+}));
+var contextConfigsRelations = drizzleOrm.relations(contextConfigs, ({ many, one }) => ({
+  project: one(projects, {
+    fields: [contextConfigs.tenantId, contextConfigs.projectId],
+    references: [projects.tenantId, projects.id]
+  }),
+  agents: many(agents),
+  cache: many(contextCache)
+}));
+var contextCacheRelations = drizzleOrm.relations(contextCache, ({ one }) => ({
+  contextConfig: one(contextConfigs, {
+    fields: [contextCache.contextConfigId],
+    references: [contextConfigs.id]
+  })
+}));
+var subAgentsRelations = drizzleOrm.relations(subAgents, ({ many, one }) => ({
+  project: one(projects, {
+    fields: [subAgents.tenantId, subAgents.projectId],
+    references: [projects.tenantId, projects.id]
+  }),
+  tasks: many(tasks),
+  defaultForAgents: many(agents),
+  sourceRelations: many(subAgentRelations, {
+    relationName: "sourceRelations"
+  }),
+  targetRelations: many(subAgentRelations, {
+    relationName: "targetRelations"
+  }),
+  sentMessages: many(messages, {
+    relationName: "sentMessages"
+  }),
+  receivedMessages: many(messages, {
+    relationName: "receivedMessages"
+  }),
+  toolRelations: many(subAgentToolRelations),
+  functionToolRelations: many(subAgentFunctionToolRelations),
+  dataComponentRelations: many(subAgentDataComponents),
+  artifactComponentRelations: many(subAgentArtifactComponents)
+}));
+var agentRelations = drizzleOrm.relations(agents, ({ one, many }) => ({
+  project: one(projects, {
+    fields: [agents.tenantId, agents.projectId],
+    references: [projects.tenantId, projects.id]
+  }),
+  defaultSubAgent: one(subAgents, {
+    fields: [agents.defaultSubAgentId],
+    references: [subAgents.id]
+  }),
+  contextConfig: one(contextConfigs, {
+    fields: [agents.contextConfigId],
+    references: [contextConfigs.id]
+  }),
+  functionTools: many(functionTools)
+}));
+var externalAgentsRelations = drizzleOrm.relations(externalAgents, ({ one, many }) => ({
+  project: one(projects, {
+    fields: [externalAgents.tenantId, externalAgents.projectId],
+    references: [projects.tenantId, projects.id]
+  }),
+  subAgentExternalAgentRelations: many(subAgentExternalAgentRelations),
+  credentialReference: one(credentialReferences, {
+    fields: [externalAgents.credentialReferenceId],
+    references: [credentialReferences.id]
+  })
+}));
+var apiKeysRelations = drizzleOrm.relations(apiKeys, ({ one }) => ({
+  project: one(projects, {
+    fields: [apiKeys.tenantId, apiKeys.projectId],
+    references: [projects.tenantId, projects.id]
+  }),
+  agent: one(agents, {
+    fields: [apiKeys.agentId],
+    references: [agents.id]
+  })
+}));
+var agentToolRelationsRelations = drizzleOrm.relations(subAgentToolRelations, ({ one }) => ({
+  subAgent: one(subAgents, {
+    fields: [subAgentToolRelations.subAgentId],
+    references: [subAgents.id]
+  }),
+  tool: one(tools, {
+    fields: [subAgentToolRelations.toolId],
+    references: [tools.id]
+  })
+}));
+var credentialReferencesRelations = drizzleOrm.relations(credentialReferences, ({ one, many }) => ({
+  project: one(projects, {
+    fields: [credentialReferences.tenantId, credentialReferences.projectId],
+    references: [projects.tenantId, projects.id]
+  }),
+  tools: many(tools),
+  externalAgents: many(externalAgents)
+}));
+var toolsRelations = drizzleOrm.relations(tools, ({ one, many }) => ({
+  project: one(projects, {
+    fields: [tools.tenantId, tools.projectId],
+    references: [projects.tenantId, projects.id]
+  }),
+  subAgentRelations: many(subAgentToolRelations),
+  credentialReference: one(credentialReferences, {
+    fields: [tools.credentialReferenceId],
+    references: [credentialReferences.id]
+  })
+}));
+var conversationsRelations = drizzleOrm.relations(conversations, ({ one, many }) => ({
+  project: one(projects, {
+    fields: [conversations.tenantId, conversations.projectId],
+    references: [projects.tenantId, projects.id]
+  }),
+  messages: many(messages),
+  activeSubAgent: one(subAgents, {
+    fields: [conversations.activeSubAgentId],
+    references: [subAgents.id]
+  })
+}));
+var messagesRelations = drizzleOrm.relations(messages, ({ one, many }) => ({
+  conversation: one(conversations, {
+    fields: [messages.conversationId],
+    references: [conversations.id]
+  }),
+  fromSubAgent: one(subAgents, {
+    fields: [messages.fromSubAgentId],
+    references: [subAgents.id],
+    relationName: "sentMessages"
+  }),
+  toSubAgent: one(subAgents, {
+    fields: [messages.toSubAgentId],
+    references: [subAgents.id],
+    relationName: "receivedMessages"
+  }),
+  fromTeamAgent: one(agents, {
+    fields: [messages.fromTeamAgentId],
+    references: [agents.id],
+    relationName: "receivedTeamMessages"
+  }),
+  toTeamAgent: one(agents, {
+    fields: [messages.toTeamAgentId],
+    references: [agents.id],
+    relationName: "sentTeamMessages"
+  }),
+  fromExternalAgent: one(externalAgents, {
+    fields: [messages.tenantId, messages.projectId, messages.fromExternalAgentId],
+    references: [externalAgents.tenantId, externalAgents.projectId, externalAgents.id],
+    relationName: "receivedExternalMessages"
+  }),
+  toExternalAgent: one(externalAgents, {
+    fields: [messages.tenantId, messages.projectId, messages.toExternalAgentId],
+    references: [externalAgents.tenantId, externalAgents.projectId, externalAgents.id],
+    relationName: "sentExternalMessages"
+  }),
+  task: one(tasks, {
+    fields: [messages.taskId],
+    references: [tasks.id]
+  }),
+  parentMessage: one(messages, {
+    fields: [messages.parentMessageId],
+    references: [messages.id],
+    relationName: "parentChild"
+  }),
+  childMessages: many(messages, {
+    relationName: "parentChild"
+  })
+}));
+var artifactComponentsRelations = drizzleOrm.relations(artifactComponents, ({ many, one }) => ({
+  project: one(projects, {
+    fields: [artifactComponents.tenantId, artifactComponents.projectId],
+    references: [projects.tenantId, projects.id]
+  }),
+  subAgentRelations: many(subAgentArtifactComponents)
+}));
+var subAgentArtifactComponentsRelations = drizzleOrm.relations(
+  subAgentArtifactComponents,
+  ({ one }) => ({
+    subAgent: one(subAgents, {
+      fields: [subAgentArtifactComponents.subAgentId],
+      references: [subAgents.id]
+    }),
+    artifactComponent: one(artifactComponents, {
+      fields: [subAgentArtifactComponents.artifactComponentId],
+      references: [artifactComponents.id]
+    })
+  })
+);
+var dataComponentsRelations = drizzleOrm.relations(dataComponents, ({ many, one }) => ({
+  project: one(projects, {
+    fields: [dataComponents.tenantId, dataComponents.projectId],
+    references: [projects.tenantId, projects.id]
+  }),
+  subAgentRelations: many(subAgentDataComponents)
+}));
+var subAgentDataComponentsRelations = drizzleOrm.relations(subAgentDataComponents, ({ one }) => ({
+  subAgent: one(subAgents, {
+    fields: [subAgentDataComponents.subAgentId],
+    references: [subAgents.id]
+  }),
+  dataComponent: one(dataComponents, {
+    fields: [subAgentDataComponents.dataComponentId],
+    references: [dataComponents.id]
+  })
+}));
+var ledgerArtifactsRelations = drizzleOrm.relations(ledgerArtifacts, ({ one }) => ({
+  project: one(projects, {
+    fields: [ledgerArtifacts.tenantId, ledgerArtifacts.projectId],
+    references: [projects.tenantId, projects.id]
+  }),
+  task: one(tasks, {
+    fields: [ledgerArtifacts.taskId],
+    references: [tasks.id]
+  })
+}));
+var functionsRelations = drizzleOrm.relations(functions, ({ many, one }) => ({
+  functionTools: many(functionTools),
+  project: one(projects, {
+    fields: [functions.tenantId, functions.projectId],
+    references: [projects.tenantId, projects.id]
+  })
+}));
+var subAgentRelationsRelations = drizzleOrm.relations(subAgentRelations, ({ one }) => ({
+  agent: one(agents, {
+    fields: [subAgentRelations.agentId],
+    references: [agents.id]
+  }),
+  sourceSubAgent: one(subAgents, {
+    fields: [subAgentRelations.sourceSubAgentId],
+    references: [subAgents.id],
+    relationName: "sourceRelations"
+  }),
+  targetSubAgent: one(subAgents, {
+    fields: [subAgentRelations.targetSubAgentId],
+    references: [subAgents.id],
+    relationName: "targetRelations"
+  })
+}));
+var functionToolsRelations = drizzleOrm.relations(functionTools, ({ one, many }) => ({
+  project: one(projects, {
+    fields: [functionTools.tenantId, functionTools.projectId],
+    references: [projects.tenantId, projects.id]
+  }),
+  agent: one(agents, {
+    fields: [functionTools.tenantId, functionTools.projectId, functionTools.agentId],
+    references: [agents.tenantId, agents.projectId, agents.id]
+  }),
+  function: one(functions, {
+    fields: [functionTools.tenantId, functionTools.projectId, functionTools.functionId],
+    references: [functions.tenantId, functions.projectId, functions.id]
+  }),
+  subAgentRelations: many(subAgentFunctionToolRelations)
+}));
+var subAgentFunctionToolRelationsRelations = drizzleOrm.relations(
+  subAgentFunctionToolRelations,
+  ({ one }) => ({
+    subAgent: one(subAgents, {
+      fields: [subAgentFunctionToolRelations.subAgentId],
+      references: [subAgents.id]
+    }),
+    functionTool: one(functionTools, {
+      fields: [subAgentFunctionToolRelations.functionToolId],
+      references: [functionTools.id]
+    })
+  })
+);
+var subAgentExternalAgentRelationsRelations = drizzleOrm.relations(
+  subAgentExternalAgentRelations,
+  ({ one }) => ({
+    subAgent: one(subAgents, {
+      fields: [
+        subAgentExternalAgentRelations.tenantId,
+        subAgentExternalAgentRelations.projectId,
+        subAgentExternalAgentRelations.agentId,
+        subAgentExternalAgentRelations.subAgentId
+      ],
+      references: [subAgents.tenantId, subAgents.projectId, subAgents.agentId, subAgents.id]
+    }),
+    externalAgent: one(externalAgents, {
+      fields: [
+        subAgentExternalAgentRelations.tenantId,
+        subAgentExternalAgentRelations.projectId,
+        subAgentExternalAgentRelations.externalAgentId
+      ],
+      references: [externalAgents.tenantId, externalAgents.projectId, externalAgents.id]
+    })
+  })
+);
+var subAgentTeamAgentRelationsRelations = drizzleOrm.relations(
+  subAgentTeamAgentRelations,
+  ({ one }) => ({
+    subAgent: one(subAgents, {
+      fields: [
+        subAgentTeamAgentRelations.tenantId,
+        subAgentTeamAgentRelations.projectId,
+        subAgentTeamAgentRelations.agentId,
+        subAgentTeamAgentRelations.subAgentId
+      ],
+      references: [subAgents.tenantId, subAgents.projectId, subAgents.agentId, subAgents.id]
+    }),
+    targetAgent: one(agents, {
+      fields: [
+        subAgentTeamAgentRelations.tenantId,
+        subAgentTeamAgentRelations.projectId,
+        subAgentTeamAgentRelations.targetAgentId
+      ],
+      references: [agents.tenantId, agents.projectId, agents.id]
+    })
+  })
+);
+var datasetRelations = drizzleOrm.relations(dataset, ({ one, many }) => ({
+  project: one(projects, {
+    fields: [dataset.tenantId, dataset.projectId],
+    references: [projects.tenantId, projects.id]
+  }),
+  items: many(datasetItem),
+  datasetRuns: many(datasetRun)
+}));
+var datasetItemRelations = drizzleOrm.relations(datasetItem, ({ one }) => ({
+  dataset: one(dataset, {
+    fields: [datasetItem.tenantId, datasetItem.projectId, datasetItem.datasetId],
+    references: [dataset.tenantId, dataset.projectId, dataset.id]
+  })
+}));
+var evaluatorRelations = drizzleOrm.relations(evaluator, ({ one, many }) => ({
+  project: one(projects, {
+    fields: [evaluator.tenantId, evaluator.projectId],
+    references: [projects.tenantId, projects.id]
+  }),
+  evaluationResults: many(evaluationResult),
+  evaluationSuiteConfigs: many(evaluationSuiteConfigEvaluatorRelations),
+  evaluationJobConfigs: many(evaluationJobConfigEvaluatorRelations)
+}));
+var datasetRunConfigRelations = drizzleOrm.relations(datasetRunConfig, ({ one, many }) => ({
+  project: one(projects, {
+    fields: [datasetRunConfig.tenantId, datasetRunConfig.projectId],
+    references: [projects.tenantId, projects.id]
+  }),
+  dataset: one(dataset, {
+    fields: [datasetRunConfig.tenantId, datasetRunConfig.projectId, datasetRunConfig.datasetId],
+    references: [dataset.tenantId, dataset.projectId, dataset.id]
+  }),
+  agents: many(datasetRunConfigAgentRelations),
+  evaluationRunConfigs: many(datasetRunConfigEvaluationRunConfigRelations),
+  runs: many(datasetRun)
+}));
+var datasetRunConfigAgentRelationsRelations = drizzleOrm.relations(
+  datasetRunConfigAgentRelations,
+  ({ one }) => ({
+    datasetRunConfig: one(datasetRunConfig, {
+      fields: [
+        datasetRunConfigAgentRelations.tenantId,
+        datasetRunConfigAgentRelations.projectId,
+        datasetRunConfigAgentRelations.datasetRunConfigId
+      ],
+      references: [datasetRunConfig.tenantId, datasetRunConfig.projectId, datasetRunConfig.id]
+    }),
+    agent: one(agents, {
+      fields: [
+        datasetRunConfigAgentRelations.tenantId,
+        datasetRunConfigAgentRelations.projectId,
+        datasetRunConfigAgentRelations.agentId
+      ],
+      references: [agents.tenantId, agents.projectId, agents.id]
+    })
+  })
+);
+var datasetRunConfigEvaluationRunConfigRelationsRelations = drizzleOrm.relations(
+  datasetRunConfigEvaluationRunConfigRelations,
+  ({ one }) => ({
+    datasetRunConfig: one(datasetRunConfig, {
+      fields: [
+        datasetRunConfigEvaluationRunConfigRelations.tenantId,
+        datasetRunConfigEvaluationRunConfigRelations.projectId,
+        datasetRunConfigEvaluationRunConfigRelations.datasetRunConfigId
+      ],
+      references: [datasetRunConfig.tenantId, datasetRunConfig.projectId, datasetRunConfig.id]
+    }),
+    evaluationRunConfig: one(evaluationRunConfig, {
+      fields: [
+        datasetRunConfigEvaluationRunConfigRelations.tenantId,
+        datasetRunConfigEvaluationRunConfigRelations.projectId,
+        datasetRunConfigEvaluationRunConfigRelations.evaluationRunConfigId
+      ],
+      references: [
+        evaluationRunConfig.tenantId,
+        evaluationRunConfig.projectId,
+        evaluationRunConfig.id
+      ]
+    })
+  })
+);
+var datasetRunRelations = drizzleOrm.relations(datasetRun, ({ one, many }) => ({
+  dataset: one(dataset, {
+    fields: [datasetRun.tenantId, datasetRun.projectId, datasetRun.datasetId],
+    references: [dataset.tenantId, dataset.projectId, dataset.id]
+  }),
+  datasetRunConfig: one(datasetRunConfig, {
+    fields: [datasetRun.tenantId, datasetRun.projectId, datasetRun.datasetRunConfigId],
+    references: [datasetRunConfig.tenantId, datasetRunConfig.projectId, datasetRunConfig.id]
+  }),
+  conversations: many(datasetRunConversationRelations)
+}));
+var evaluationSuiteConfigRelations = drizzleOrm.relations(evaluationSuiteConfig, ({ one, many }) => ({
+  project: one(projects, {
+    fields: [evaluationSuiteConfig.tenantId, evaluationSuiteConfig.projectId],
+    references: [projects.tenantId, projects.id]
+  }),
+  runConfigs: many(evaluationRunConfigEvaluationSuiteConfigRelations),
+  evaluators: many(evaluationSuiteConfigEvaluatorRelations)
+}));
+var evaluationSuiteConfigEvaluatorRelationsRelations = drizzleOrm.relations(
+  evaluationSuiteConfigEvaluatorRelations,
+  ({ one }) => ({
+    evaluationSuiteConfig: one(evaluationSuiteConfig, {
+      fields: [
+        evaluationSuiteConfigEvaluatorRelations.tenantId,
+        evaluationSuiteConfigEvaluatorRelations.projectId,
+        evaluationSuiteConfigEvaluatorRelations.evaluationSuiteConfigId
+      ],
+      references: [
+        evaluationSuiteConfig.tenantId,
+        evaluationSuiteConfig.projectId,
+        evaluationSuiteConfig.id
+      ]
+    }),
+    evaluator: one(evaluator, {
+      fields: [
+        evaluationSuiteConfigEvaluatorRelations.tenantId,
+        evaluationSuiteConfigEvaluatorRelations.projectId,
+        evaluationSuiteConfigEvaluatorRelations.evaluatorId
+      ],
+      references: [evaluator.tenantId, evaluator.projectId, evaluator.id]
+    })
+  })
+);
+var evaluationJobConfigEvaluatorRelationsRelations = drizzleOrm.relations(
+  evaluationJobConfigEvaluatorRelations,
+  ({ one }) => ({
+    evaluationJobConfig: one(evaluationJobConfig, {
+      fields: [
+        evaluationJobConfigEvaluatorRelations.tenantId,
+        evaluationJobConfigEvaluatorRelations.projectId,
+        evaluationJobConfigEvaluatorRelations.evaluationJobConfigId
+      ],
+      references: [
+        evaluationJobConfig.tenantId,
+        evaluationJobConfig.projectId,
+        evaluationJobConfig.id
+      ]
+    }),
+    evaluator: one(evaluator, {
+      fields: [
+        evaluationJobConfigEvaluatorRelations.tenantId,
+        evaluationJobConfigEvaluatorRelations.projectId,
+        evaluationJobConfigEvaluatorRelations.evaluatorId
+      ],
+      references: [evaluator.tenantId, evaluator.projectId, evaluator.id]
+    })
+  })
+);
+var evaluationJobConfigRelations = drizzleOrm.relations(evaluationJobConfig, ({ one, many }) => ({
+  project: one(projects, {
+    fields: [evaluationJobConfig.tenantId, evaluationJobConfig.projectId],
+    references: [projects.tenantId, projects.id]
+  }),
+  run: one(evaluationRun, {
+    fields: [evaluationJobConfig.tenantId, evaluationJobConfig.projectId, evaluationJobConfig.id],
+    references: [
+      evaluationRun.tenantId,
+      evaluationRun.projectId,
+      evaluationRun.evaluationJobConfigId
+    ]
+  }),
+  evaluators: many(evaluationJobConfigEvaluatorRelations)
+}));
+var evaluationRunConfigEvaluationSuiteConfigRelationsRelations = drizzleOrm.relations(
+  evaluationRunConfigEvaluationSuiteConfigRelations,
+  ({ one }) => ({
+    evaluationRunConfig: one(evaluationRunConfig, {
+      fields: [
+        evaluationRunConfigEvaluationSuiteConfigRelations.tenantId,
+        evaluationRunConfigEvaluationSuiteConfigRelations.projectId,
+        evaluationRunConfigEvaluationSuiteConfigRelations.evaluationRunConfigId
+      ],
+      references: [
+        evaluationRunConfig.tenantId,
+        evaluationRunConfig.projectId,
+        evaluationRunConfig.id
+      ]
+    }),
+    evaluationSuiteConfig: one(evaluationSuiteConfig, {
+      fields: [
+        evaluationRunConfigEvaluationSuiteConfigRelations.tenantId,
+        evaluationRunConfigEvaluationSuiteConfigRelations.projectId,
+        evaluationRunConfigEvaluationSuiteConfigRelations.evaluationSuiteConfigId
+      ],
+      references: [
+        evaluationSuiteConfig.tenantId,
+        evaluationSuiteConfig.projectId,
+        evaluationSuiteConfig.id
+      ]
+    })
+  })
+);
+var evaluationRunConfigRelations = drizzleOrm.relations(evaluationRunConfig, ({ one, many }) => ({
+  project: one(projects, {
+    fields: [evaluationRunConfig.tenantId, evaluationRunConfig.projectId],
+    references: [projects.tenantId, projects.id]
+  }),
+  suiteConfigs: many(evaluationRunConfigEvaluationSuiteConfigRelations),
+  datasetRunConfigs: many(datasetRunConfigEvaluationRunConfigRelations),
+  runs: many(evaluationRun)
+}));
+var evaluationRunRelations = drizzleOrm.relations(evaluationRun, ({ one, many }) => ({
+  evaluationJobConfig: one(evaluationJobConfig, {
+    fields: [evaluationRun.tenantId, evaluationRun.projectId, evaluationRun.evaluationJobConfigId],
+    references: [
+      evaluationJobConfig.tenantId,
+      evaluationJobConfig.projectId,
+      evaluationJobConfig.id
+    ]
+  }),
+  evaluationRunConfig: one(evaluationRunConfig, {
+    fields: [evaluationRun.tenantId, evaluationRun.projectId, evaluationRun.evaluationRunConfigId],
+    references: [
+      evaluationRunConfig.tenantId,
+      evaluationRunConfig.projectId,
+      evaluationRunConfig.id
+    ]
+  }),
+  results: many(evaluationResult)
+}));
+var evaluationResultRelations = drizzleOrm.relations(evaluationResult, ({ one }) => ({
+  conversation: one(conversations, {
+    fields: [
+      evaluationResult.tenantId,
+      evaluationResult.projectId,
+      evaluationResult.conversationId
+    ],
+    references: [conversations.tenantId, conversations.projectId, conversations.id],
+    relationName: "conversationEvaluationResults"
+  }),
+  evaluator: one(evaluator, {
+    fields: [evaluationResult.tenantId, evaluationResult.projectId, evaluationResult.evaluatorId],
+    references: [evaluator.tenantId, evaluator.projectId, evaluator.id]
+  }),
+  evaluationRun: one(evaluationRun, {
+    fields: [
+      evaluationResult.tenantId,
+      evaluationResult.projectId,
+      evaluationResult.evaluationRunId
+    ],
+    references: [evaluationRun.tenantId, evaluationRun.projectId, evaluationRun.id]
+  })
+}));
+var conversationsEvaluatorRelations = drizzleOrm.relations(conversations, ({ many }) => ({
+  evaluationResults: many(evaluationResult, {
+    relationName: "conversationEvaluationResults"
+  })
+}));
+var datasetRunConversationRelationsRelations = drizzleOrm.relations(
+  datasetRunConversationRelations,
+  ({ one }) => ({
+    datasetRun: one(datasetRun, {
+      fields: [
+        datasetRunConversationRelations.tenantId,
+        datasetRunConversationRelations.projectId,
+        datasetRunConversationRelations.datasetRunId
+      ],
+      references: [datasetRun.tenantId, datasetRun.projectId, datasetRun.id]
+    }),
+    conversation: one(conversations, {
+      fields: [
+        datasetRunConversationRelations.tenantId,
+        datasetRunConversationRelations.projectId,
+        datasetRunConversationRelations.conversationId
+      ],
+      references: [conversations.tenantId, conversations.projectId, conversations.id]
+    })
+  })
+);
+
+exports.agentRelations = agentRelations;
+exports.agentToolRelationsRelations = agentToolRelationsRelations;
+exports.agents = agents;
+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.conversationsEvaluatorRelations = conversationsEvaluatorRelations;
+exports.conversationsRelations = conversationsRelations;
+exports.credentialReferences = credentialReferences;
+exports.credentialReferencesRelations = credentialReferencesRelations;
+exports.dataComponents = dataComponents;
+exports.dataComponentsRelations = dataComponentsRelations;
+exports.dataset = dataset;
+exports.datasetItem = datasetItem;
+exports.datasetItemRelations = datasetItemRelations;
+exports.datasetRelations = datasetRelations;
+exports.datasetRun = datasetRun;
+exports.datasetRunConfig = datasetRunConfig;
+exports.datasetRunConfigAgentRelations = datasetRunConfigAgentRelations;
+exports.datasetRunConfigAgentRelationsRelations = datasetRunConfigAgentRelationsRelations;
+exports.datasetRunConfigEvaluationRunConfigRelations = datasetRunConfigEvaluationRunConfigRelations;
+exports.datasetRunConfigEvaluationRunConfigRelationsRelations = datasetRunConfigEvaluationRunConfigRelationsRelations;
+exports.datasetRunConfigRelations = datasetRunConfigRelations;
+exports.datasetRunConversationRelations = datasetRunConversationRelations;
+exports.datasetRunConversationRelationsRelations = datasetRunConversationRelationsRelations;
+exports.datasetRunRelations = datasetRunRelations;
+exports.evaluationJobConfig = evaluationJobConfig;
+exports.evaluationJobConfigEvaluatorRelations = evaluationJobConfigEvaluatorRelations;
+exports.evaluationJobConfigEvaluatorRelationsRelations = evaluationJobConfigEvaluatorRelationsRelations;
+exports.evaluationJobConfigRelations = evaluationJobConfigRelations;
+exports.evaluationResult = evaluationResult;
+exports.evaluationResultRelations = evaluationResultRelations;
+exports.evaluationRun = evaluationRun;
+exports.evaluationRunConfig = evaluationRunConfig;
+exports.evaluationRunConfigEvaluationSuiteConfigRelations = evaluationRunConfigEvaluationSuiteConfigRelations;
+exports.evaluationRunConfigEvaluationSuiteConfigRelationsRelations = evaluationRunConfigEvaluationSuiteConfigRelationsRelations;
+exports.evaluationRunConfigRelations = evaluationRunConfigRelations;
+exports.evaluationRunRelations = evaluationRunRelations;
+exports.evaluationSuiteConfig = evaluationSuiteConfig;
+exports.evaluationSuiteConfigEvaluatorRelations = evaluationSuiteConfigEvaluatorRelations;
+exports.evaluationSuiteConfigEvaluatorRelationsRelations = evaluationSuiteConfigEvaluatorRelationsRelations;
+exports.evaluationSuiteConfigRelations = evaluationSuiteConfigRelations;
+exports.evaluator = evaluator;
+exports.evaluatorRelations = evaluatorRelations;
+exports.externalAgents = externalAgents;
+exports.externalAgentsRelations = externalAgentsRelations;
+exports.functionTools = functionTools;
+exports.functionToolsRelations = functionToolsRelations;
+exports.functions = functions;
+exports.functionsRelations = functionsRelations;
+exports.ledgerArtifacts = ledgerArtifacts;
+exports.ledgerArtifactsRelations = ledgerArtifactsRelations;
+exports.messages = messages;
+exports.messagesRelations = messagesRelations;
+exports.projects = projects;
+exports.projectsRelations = projectsRelations;
+exports.subAgentArtifactComponents = subAgentArtifactComponents;
+exports.subAgentArtifactComponentsRelations = subAgentArtifactComponentsRelations;
+exports.subAgentDataComponents = subAgentDataComponents;
+exports.subAgentDataComponentsRelations = subAgentDataComponentsRelations;
+exports.subAgentExternalAgentRelations = subAgentExternalAgentRelations;
+exports.subAgentExternalAgentRelationsRelations = subAgentExternalAgentRelationsRelations;
+exports.subAgentFunctionToolRelations = subAgentFunctionToolRelations;
+exports.subAgentFunctionToolRelationsRelations = subAgentFunctionToolRelationsRelations;
+exports.subAgentRelations = subAgentRelations;
+exports.subAgentRelationsRelations = subAgentRelationsRelations;
+exports.subAgentTeamAgentRelations = subAgentTeamAgentRelations;
+exports.subAgentTeamAgentRelationsRelations = subAgentTeamAgentRelationsRelations;
+exports.subAgentToolRelations = subAgentToolRelations;
+exports.subAgents = subAgents;
+exports.subAgentsRelations = subAgentsRelations;
+exports.taskRelations = taskRelations;
+exports.taskRelationsRelations = taskRelationsRelations;
+exports.tasks = tasks;
+exports.tasksRelations = tasksRelations;
+exports.tools = tools;
+exports.toolsRelations = toolsRelations;