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

package/dist/chunk-A6JWG7FI.js

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