@inkeep/agents-core 0.31.6 → 0.32.0

package/dist/db/schema.cjs

@@ -1,169 +1,169 @@
 'use strict';
 
 var drizzleOrm = require('drizzle-orm');
-var sqliteCore = require('drizzle-orm/sqlite-core');
+var pgCore = require('drizzle-orm/pg-core');
 
 // src/db/schema.ts
 var tenantScoped = {
-  tenantId: sqliteCore.text("tenant_id").notNull(),
-  id: sqliteCore.text("id").notNull()
+  tenantId: pgCore.varchar("tenant_id", { length: 256 }).notNull(),
+  id: pgCore.varchar("id", { length: 256 }).notNull()
 };
 var projectScoped = {
   ...tenantScoped,
-  projectId: sqliteCore.text("project_id").notNull()
+  projectId: pgCore.varchar("project_id", { length: 256 }).notNull()
 };
 var agentScoped = {
   ...projectScoped,
-  agentId: sqliteCore.text("agent_id").notNull()
+  agentId: pgCore.varchar("agent_id", { length: 256 }).notNull()
 };
 var subAgentScoped = {
   ...agentScoped,
-  subAgentId: sqliteCore.text("sub_agent_id").notNull()
+  subAgentId: pgCore.varchar("sub_agent_id", { length: 256 }).notNull()
 };
 var uiProperties = {
-  name: sqliteCore.text("name").notNull(),
-  description: sqliteCore.text("description").notNull()
+  name: pgCore.varchar("name", { length: 256 }).notNull(),
+  description: pgCore.text("description").notNull()
 };
 var timestamps = {
-  createdAt: sqliteCore.text("created_at").notNull().default(drizzleOrm.sql`CURRENT_TIMESTAMP`),
-  updatedAt: sqliteCore.text("updated_at").notNull().default(drizzleOrm.sql`CURRENT_TIMESTAMP`)
+  createdAt: pgCore.timestamp("created_at", { mode: "string" }).notNull().defaultNow(),
+  updatedAt: pgCore.timestamp("updated_at", { mode: "string" }).notNull().defaultNow()
 };
-var projects = sqliteCore.sqliteTable(
+var projects = pgCore.pgTable(
   "projects",
   {
     ...tenantScoped,
     ...uiProperties,
-    models: sqliteCore.text("models", { mode: "json" }).$type(),
-    stopWhen: sqliteCore.text("stop_when", { mode: "json" }).$type(),
+    models: pgCore.jsonb("models").$type(),
+    stopWhen: pgCore.jsonb("stop_when").$type(),
     ...timestamps
   },
-  (table) => [sqliteCore.primaryKey({ columns: [table.tenantId, table.id] })]
+  (table) => [pgCore.primaryKey({ columns: [table.tenantId, table.id] })]
 );
-var agents = sqliteCore.sqliteTable(
+var agents = pgCore.pgTable(
   "agent",
   {
     ...projectScoped,
-    name: sqliteCore.text("name").notNull(),
-    description: sqliteCore.text("description"),
-    defaultSubAgentId: sqliteCore.text("default_sub_agent_id"),
-    contextConfigId: sqliteCore.text("context_config_id"),
-    models: sqliteCore.text("models", { mode: "json" }).$type(),
-    statusUpdates: sqliteCore.text("status_updates", { mode: "json" }).$type(),
-    prompt: sqliteCore.text("prompt"),
-    stopWhen: sqliteCore.text("stop_when", { mode: "json" }).$type(),
+    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) => [
-    sqliteCore.primaryKey({ columns: [table.tenantId, table.projectId, table.id] }),
-    sqliteCore.foreignKey({
+    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 = sqliteCore.sqliteTable(
+var contextConfigs = pgCore.pgTable(
   "context_configs",
   {
     ...agentScoped,
-    headersSchema: sqliteCore.blob("headers_schema", { mode: "json" }).$type(),
-    contextVariables: sqliteCore.blob("context_variables", { mode: "json" }).$type(),
+    headersSchema: pgCore.jsonb("headers_schema").$type(),
+    contextVariables: pgCore.jsonb("context_variables").$type(),
     ...timestamps
   },
   (table) => [
-    sqliteCore.primaryKey({ columns: [table.tenantId, table.projectId, table.agentId, table.id] }),
-    sqliteCore.foreignKey({
+    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 = sqliteCore.sqliteTable(
+var contextCache = pgCore.pgTable(
   "context_cache",
   {
     ...projectScoped,
-    conversationId: sqliteCore.text("conversation_id").notNull(),
-    contextConfigId: sqliteCore.text("context_config_id").notNull(),
-    contextVariableKey: sqliteCore.text("context_variable_key").notNull(),
-    value: sqliteCore.blob("value", { mode: "json" }).$type().notNull(),
-    requestHash: sqliteCore.text("request_hash"),
-    fetchedAt: sqliteCore.text("fetched_at").notNull(),
-    fetchSource: sqliteCore.text("fetch_source"),
-    fetchDurationMs: sqliteCore.integer("fetch_duration_ms"),
+    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) => [
-    sqliteCore.primaryKey({ columns: [table.tenantId, table.projectId, table.id] }),
-    sqliteCore.foreignKey({
+    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"),
-    sqliteCore.index("context_cache_lookup_idx").on(
+    pgCore.index("context_cache_lookup_idx").on(
       table.conversationId,
       table.contextConfigId,
       table.contextVariableKey
     )
   ]
 );
-var subAgents = sqliteCore.sqliteTable(
+var subAgents = pgCore.pgTable(
   "sub_agents",
   {
     ...agentScoped,
     ...uiProperties,
-    prompt: sqliteCore.text("prompt").notNull(),
-    conversationHistoryConfig: sqliteCore.text("conversation_history_config", {
-      mode: "json"
-    }).$type(),
-    models: sqliteCore.text("models", { mode: "json" }).$type(),
-    stopWhen: sqliteCore.text("stop_when", { mode: "json" }).$type(),
+    prompt: pgCore.text("prompt").notNull(),
+    conversationHistoryConfig: pgCore.jsonb(
+      "conversation_history_config"
+    ).$type(),
+    models: pgCore.jsonb("models").$type(),
+    stopWhen: pgCore.jsonb("stop_when").$type(),
     ...timestamps
   },
   (table) => [
-    sqliteCore.primaryKey({ columns: [table.tenantId, table.projectId, table.agentId, table.id] }),
-    sqliteCore.foreignKey({
+    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 = sqliteCore.sqliteTable(
+var subAgentRelations = pgCore.pgTable(
   "sub_agent_relations",
   {
     ...agentScoped,
-    sourceSubAgentId: sqliteCore.text("source_sub_agent_id").notNull(),
-    targetSubAgentId: sqliteCore.text("target_sub_agent_id"),
-    relationType: sqliteCore.text("relation_type"),
+    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) => [
-    sqliteCore.primaryKey({ columns: [table.tenantId, table.projectId, table.agentId, table.id] }),
-    sqliteCore.foreignKey({
+    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 = sqliteCore.sqliteTable(
+var externalAgents = pgCore.pgTable(
   "external_agents",
   {
     ...projectScoped,
     ...uiProperties,
-    baseUrl: sqliteCore.text("base_url").notNull(),
-    credentialReferenceId: sqliteCore.text("credential_reference_id"),
+    baseUrl: pgCore.text("base_url").notNull(),
+    credentialReferenceId: pgCore.varchar("credential_reference_id", { length: 256 }),
     ...timestamps
   },
   (table) => [
-    sqliteCore.primaryKey({ columns: [table.tenantId, table.projectId, table.id] }),
-    sqliteCore.foreignKey({
+    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"),
-    sqliteCore.foreignKey({
+    pgCore.foreignKey({
       columns: [table.tenantId, table.projectId, table.credentialReferenceId],
       foreignColumns: [
         credentialReferences.tenantId,
@@ -171,118 +171,118 @@ var externalAgents = sqliteCore.sqliteTable(
         credentialReferences.id
       ],
       name: "external_agents_credential_reference_fk"
-    }).onDelete("set null")
+    }).onDelete("cascade")
   ]
 );
-var tasks = sqliteCore.sqliteTable(
+var tasks = pgCore.pgTable(
   "tasks",
   {
     ...subAgentScoped,
-    contextId: sqliteCore.text("context_id").notNull(),
-    status: sqliteCore.text("status").notNull(),
-    metadata: sqliteCore.blob("metadata", { mode: "json" }).$type(),
+    contextId: pgCore.varchar("context_id", { length: 256 }).notNull(),
+    status: pgCore.varchar("status", { length: 256 }).notNull(),
+    metadata: pgCore.jsonb("metadata").$type(),
     ...timestamps
   },
   (table) => [
-    sqliteCore.primaryKey({ columns: [table.tenantId, table.projectId, table.id] }),
-    sqliteCore.foreignKey({
+    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 = sqliteCore.sqliteTable(
+var taskRelations = pgCore.pgTable(
   "task_relations",
   {
     ...projectScoped,
-    parentTaskId: sqliteCore.text("parent_task_id").notNull(),
-    childTaskId: sqliteCore.text("child_task_id").notNull(),
-    relationType: sqliteCore.text("relation_type").default("parent_child"),
+    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) => [
-    sqliteCore.primaryKey({ columns: [table.tenantId, table.projectId, table.id] }),
-    sqliteCore.foreignKey({
+    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 = sqliteCore.sqliteTable(
+var dataComponents = pgCore.pgTable(
   "data_components",
   {
     ...projectScoped,
     ...uiProperties,
-    props: sqliteCore.blob("props", { mode: "json" }).$type(),
-    render: sqliteCore.blob("render", { mode: "json" }).$type(),
+    props: pgCore.jsonb("props").$type(),
+    render: pgCore.jsonb("render").$type(),
     ...timestamps
   },
   (table) => [
-    sqliteCore.primaryKey({ columns: [table.tenantId, table.projectId, table.id] }),
-    sqliteCore.foreignKey({
+    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 = sqliteCore.sqliteTable(
+var subAgentDataComponents = pgCore.pgTable(
   "sub_agent_data_components",
   {
     ...subAgentScoped,
-    dataComponentId: sqliteCore.text("data_component_id").notNull(),
-    createdAt: sqliteCore.text("created_at").notNull().default(drizzleOrm.sql`CURRENT_TIMESTAMP`)
+    dataComponentId: pgCore.varchar("data_component_id", { length: 256 }).notNull(),
+    createdAt: pgCore.timestamp("created_at", { mode: "string" }).notNull().defaultNow()
   },
   (table) => [
-    sqliteCore.primaryKey({ columns: [table.tenantId, table.projectId, table.id] }),
-    sqliteCore.foreignKey({
+    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"),
-    sqliteCore.foreignKey({
+    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 = sqliteCore.sqliteTable(
+var artifactComponents = pgCore.pgTable(
   "artifact_components",
   {
     ...projectScoped,
     ...uiProperties,
-    props: sqliteCore.blob("props", { mode: "json" }).$type(),
+    props: pgCore.jsonb("props").$type(),
     ...timestamps
   },
   (table) => [
-    sqliteCore.primaryKey({ columns: [table.tenantId, table.projectId, table.id] }),
-    sqliteCore.foreignKey({
+    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 = sqliteCore.sqliteTable(
+var subAgentArtifactComponents = pgCore.pgTable(
   "sub_agent_artifact_components",
   {
     ...subAgentScoped,
-    artifactComponentId: sqliteCore.text("artifact_component_id").notNull(),
-    createdAt: sqliteCore.text("created_at").notNull().default(drizzleOrm.sql`CURRENT_TIMESTAMP`)
+    artifactComponentId: pgCore.varchar("artifact_component_id", { length: 256 }).notNull(),
+    createdAt: pgCore.timestamp("created_at", { mode: "string" }).notNull().defaultNow()
   },
   (table) => [
-    sqliteCore.primaryKey({
+    pgCore.primaryKey({
       columns: [table.tenantId, table.projectId, table.agentId, table.subAgentId, table.id]
     }),
-    sqliteCore.foreignKey({
+    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"),
-    sqliteCore.foreignKey({
+    pgCore.foreignKey({
       columns: [table.tenantId, table.projectId, table.artifactComponentId],
       foreignColumns: [
         artifactComponents.tenantId,
@@ -293,152 +293,152 @@ var subAgentArtifactComponents = sqliteCore.sqliteTable(
     }).onDelete("cascade")
   ]
 );
-var tools = sqliteCore.sqliteTable(
+var tools = pgCore.pgTable(
   "tools",
   {
     ...projectScoped,
-    name: sqliteCore.text("name").notNull(),
-    description: sqliteCore.text("description"),
-    config: sqliteCore.blob("config", { mode: "json" }).$type().notNull(),
-    credentialReferenceId: sqliteCore.text("credential_reference_id"),
-    headers: sqliteCore.blob("headers", { mode: "json" }).$type(),
-    imageUrl: sqliteCore.text("image_url"),
-    capabilities: sqliteCore.blob("capabilities", { mode: "json" }).$type(),
-    lastError: sqliteCore.text("last_error"),
+    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) => [
-    sqliteCore.primaryKey({ columns: [table.tenantId, table.projectId, table.id] }),
-    sqliteCore.foreignKey({
+    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 = sqliteCore.sqliteTable(
+var functionTools = pgCore.pgTable(
   "function_tools",
   {
     ...agentScoped,
-    name: sqliteCore.text("name").notNull(),
-    description: sqliteCore.text("description"),
-    functionId: sqliteCore.text("function_id").notNull(),
+    name: pgCore.varchar("name", { length: 256 }).notNull(),
+    description: pgCore.text("description"),
+    functionId: pgCore.varchar("function_id", { length: 256 }).notNull(),
     ...timestamps
   },
   (table) => [
-    sqliteCore.primaryKey({ columns: [table.tenantId, table.projectId, table.agentId, table.id] }),
-    sqliteCore.foreignKey({
+    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"),
-    sqliteCore.foreignKey({
+    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 = sqliteCore.sqliteTable(
+var functions = pgCore.pgTable(
   "functions",
   {
     ...projectScoped,
-    inputSchema: sqliteCore.blob("input_schema", { mode: "json" }).$type(),
-    executeCode: sqliteCore.text("execute_code").notNull(),
-    dependencies: sqliteCore.blob("dependencies", { mode: "json" }).$type(),
+    inputSchema: pgCore.jsonb("input_schema").$type(),
+    executeCode: pgCore.text("execute_code").notNull(),
+    dependencies: pgCore.jsonb("dependencies").$type(),
     ...timestamps
   },
   (table) => [
-    sqliteCore.primaryKey({ columns: [table.tenantId, table.projectId, table.id] }),
-    sqliteCore.foreignKey({
+    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 = sqliteCore.sqliteTable(
+var subAgentToolRelations = pgCore.pgTable(
   "sub_agent_tool_relations",
   {
     ...subAgentScoped,
-    toolId: sqliteCore.text("tool_id").notNull(),
-    selectedTools: sqliteCore.blob("selected_tools", { mode: "json" }).$type(),
-    headers: sqliteCore.blob("headers", { mode: "json" }).$type(),
+    toolId: pgCore.varchar("tool_id", { length: 256 }).notNull(),
+    selectedTools: pgCore.jsonb("selected_tools").$type(),
+    headers: pgCore.jsonb("headers").$type(),
     ...timestamps
   },
   (table) => [
-    sqliteCore.primaryKey({ columns: [table.tenantId, table.projectId, table.agentId, table.id] }),
-    sqliteCore.foreignKey({
+    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"),
-    sqliteCore.foreignKey({
+    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 = sqliteCore.sqliteTable(
+var subAgentExternalAgentRelations = pgCore.pgTable(
   "sub_agent_external_agent_relations",
   {
     ...subAgentScoped,
-    externalAgentId: sqliteCore.text("external_agent_id").notNull(),
-    headers: sqliteCore.blob("headers", { mode: "json" }).$type(),
+    externalAgentId: pgCore.varchar("external_agent_id", { length: 256 }).notNull(),
+    headers: pgCore.jsonb("headers").$type(),
     ...timestamps
   },
   (table) => [
-    sqliteCore.primaryKey({ columns: [table.tenantId, table.projectId, table.agentId, table.id] }),
-    sqliteCore.foreignKey({
+    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"),
-    sqliteCore.foreignKey({
+    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 = sqliteCore.sqliteTable(
+var subAgentTeamAgentRelations = pgCore.pgTable(
   "sub_agent_team_agent_relations",
   {
     ...subAgentScoped,
-    targetAgentId: sqliteCore.text("target_agent_id").notNull(),
-    headers: sqliteCore.blob("headers", { mode: "json" }).$type(),
+    targetAgentId: pgCore.varchar("target_agent_id", { length: 256 }).notNull(),
+    headers: pgCore.jsonb("headers").$type(),
     ...timestamps
   },
   (table) => [
-    sqliteCore.primaryKey({ columns: [table.tenantId, table.projectId, table.agentId, table.id] }),
-    sqliteCore.foreignKey({
+    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"),
-    sqliteCore.foreignKey({
+    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 = sqliteCore.sqliteTable(
+var subAgentFunctionToolRelations = pgCore.pgTable(
   "sub_agent_function_tool_relations",
   {
     ...subAgentScoped,
-    functionToolId: sqliteCore.text("function_tool_id").notNull(),
+    functionToolId: pgCore.varchar("function_tool_id", { length: 256 }).notNull(),
     ...timestamps
   },
   (table) => [
-    sqliteCore.primaryKey({ columns: [table.tenantId, table.projectId, table.agentId, table.id] }),
-    sqliteCore.foreignKey({
+    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"),
-    sqliteCore.foreignKey({
+    pgCore.foreignKey({
       columns: [table.tenantId, table.projectId, table.agentId, table.functionToolId],
       foreignColumns: [
         functionTools.tenantId,
@@ -450,134 +450,134 @@ var subAgentFunctionToolRelations = sqliteCore.sqliteTable(
     }).onDelete("cascade")
   ]
 );
-var conversations = sqliteCore.sqliteTable(
+var conversations = pgCore.pgTable(
   "conversations",
   {
     ...projectScoped,
-    userId: sqliteCore.text("user_id"),
-    activeSubAgentId: sqliteCore.text("active_sub_agent_id").notNull(),
-    title: sqliteCore.text("title"),
-    lastContextResolution: sqliteCore.text("last_context_resolution"),
-    metadata: sqliteCore.blob("metadata", { mode: "json" }).$type(),
+    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) => [
-    sqliteCore.primaryKey({ columns: [table.tenantId, table.projectId, table.id] }),
-    sqliteCore.foreignKey({
+    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 = sqliteCore.sqliteTable(
+var messages = pgCore.pgTable(
   "messages",
   {
     ...projectScoped,
-    conversationId: sqliteCore.text("conversation_id").notNull(),
-    role: sqliteCore.text("role").notNull(),
-    fromSubAgentId: sqliteCore.text("from_sub_agent_id"),
-    toSubAgentId: sqliteCore.text("to_sub_agent_id"),
-    fromExternalAgentId: sqliteCore.text("from_external_sub_agent_id"),
-    toExternalAgentId: sqliteCore.text("to_external_sub_agent_id"),
-    fromTeamAgentId: sqliteCore.text("from_team_agent_id"),
-    toTeamAgentId: sqliteCore.text("to_team_agent_id"),
-    content: sqliteCore.blob("content", { mode: "json" }).$type().notNull(),
-    visibility: sqliteCore.text("visibility").notNull().default("user-facing"),
-    messageType: sqliteCore.text("message_type").notNull().default("chat"),
-    taskId: sqliteCore.text("task_id"),
-    parentMessageId: sqliteCore.text("parent_message_id"),
-    a2aTaskId: sqliteCore.text("a2a_task_id"),
-    a2aSessionId: sqliteCore.text("a2a_session_id"),
-    metadata: sqliteCore.blob("metadata", { mode: "json" }).$type(),
+    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) => [
-    sqliteCore.primaryKey({ columns: [table.tenantId, table.projectId, table.id] }),
-    sqliteCore.foreignKey({
+    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 = sqliteCore.sqliteTable(
+var ledgerArtifacts = pgCore.pgTable(
   "ledger_artifacts",
   {
     ...projectScoped,
-    taskId: sqliteCore.text("task_id").notNull(),
-    toolCallId: sqliteCore.text("tool_call_id"),
-    contextId: sqliteCore.text("context_id").notNull(),
-    type: sqliteCore.text("type").notNull().default("source"),
-    name: sqliteCore.text("name"),
-    description: sqliteCore.text("description"),
-    parts: sqliteCore.blob("parts", { mode: "json" }).$type(),
-    metadata: sqliteCore.blob("metadata", { mode: "json" }).$type(),
-    summary: sqliteCore.text("summary"),
-    mime: sqliteCore.blob("mime", { mode: "json" }).$type(),
-    visibility: sqliteCore.text("visibility").default("context"),
-    allowedAgents: sqliteCore.blob("allowed_agents", { mode: "json" }).$type(),
-    derivedFrom: sqliteCore.text("derived_from"),
+    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) => [
-    sqliteCore.primaryKey({ columns: [table.tenantId, table.projectId, table.id, table.taskId] }),
-    sqliteCore.foreignKey({
+    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"),
-    sqliteCore.index("ledger_artifacts_task_id_idx").on(table.taskId),
-    sqliteCore.index("ledger_artifacts_tool_call_id_idx").on(table.toolCallId),
-    sqliteCore.index("ledger_artifacts_context_id_idx").on(table.contextId),
-    sqliteCore.unique("ledger_artifacts_task_context_name_unique").on(
+    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 = sqliteCore.sqliteTable(
+var apiKeys = pgCore.pgTable(
   "api_keys",
   {
     ...agentScoped,
-    publicId: sqliteCore.text("public_id").notNull().unique(),
-    keyHash: sqliteCore.text("key_hash").notNull(),
-    keyPrefix: sqliteCore.text("key_prefix").notNull(),
-    name: sqliteCore.text("name"),
-    lastUsedAt: sqliteCore.text("last_used_at"),
-    expiresAt: sqliteCore.text("expires_at"),
+    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) => [
-    sqliteCore.foreignKey({
+    pgCore.foreignKey({
       columns: [t.tenantId, t.projectId],
       foreignColumns: [projects.tenantId, projects.id],
       name: "api_keys_project_fk"
     }).onDelete("cascade"),
-    sqliteCore.foreignKey({
+    pgCore.foreignKey({
       columns: [t.tenantId, t.projectId, t.agentId],
       foreignColumns: [agents.tenantId, agents.projectId, agents.id],
       name: "api_keys_agent_fk"
     }).onDelete("cascade"),
-    sqliteCore.index("api_keys_tenant_agent_idx").on(t.tenantId, t.agentId),
-    sqliteCore.index("api_keys_prefix_idx").on(t.keyPrefix),
-    sqliteCore.index("api_keys_public_id_idx").on(t.publicId)
+    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 = sqliteCore.sqliteTable(
+var credentialReferences = pgCore.pgTable(
   "credential_references",
   {
     ...projectScoped,
-    name: sqliteCore.text("name").notNull(),
-    type: sqliteCore.text("type").notNull(),
-    credentialStoreId: sqliteCore.text("credential_store_id").notNull(),
-    retrievalParams: sqliteCore.blob("retrieval_params", { mode: "json" }).$type(),
+    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) => [
-    sqliteCore.primaryKey({ columns: [t.tenantId, t.projectId, t.id] }),
-    sqliteCore.foreignKey({
+    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"