@inkeep/agents-core 0.31.7 → 0.32.0

package/dist/client-exports.cjs

@@ -4,7 +4,7 @@ var zod = require('zod');
 var zodOpenapi = require('@hono/zod-openapi');
 var drizzleZod = require('drizzle-zod');
 var drizzleOrm = require('drizzle-orm');
-var sqliteCore = require('drizzle-orm/sqlite-core');
+var pgCore = require('drizzle-orm/pg-core');
 var Ajv = require('ajv');
 var auth_js = require('@modelcontextprotocol/sdk/client/auth.js');
 
@@ -14,6 +14,38 @@ var Ajv__default = /*#__PURE__*/_interopDefault(Ajv);
 
 // src/client-exports.ts
 
+// src/constants/schema-validation/defaults.ts
+var schemaValidationDefaults = {
+  // Agent Execution Transfer Count
+  // Controls how many times an agent can transfer control to sub-agents in a single conversation turn.
+  // This prevents infinite transfer loops while allowing multi-agent collaboration workflows.
+  AGENT_EXECUTION_TRANSFER_COUNT_MIN: 1,
+  AGENT_EXECUTION_TRANSFER_COUNT_MAX: 1e3,
+  // Sub-Agent Turn Generation Steps
+  // Limits how many AI generation steps a sub-agent can perform within a single turn.
+  // Each generation step typically involves sending a prompt to the LLM and processing its response.
+  // This prevents runaway token usage while allowing complex multi-step reasoning.
+  SUB_AGENT_TURN_GENERATION_STEPS_MIN: 1,
+  SUB_AGENT_TURN_GENERATION_STEPS_MAX: 1e3,
+  // Status Update Thresholds
+  // Real-time status updates are triggered when either threshold is exceeded during longer operations.
+  // MAX_NUM_EVENTS: Maximum number of internal events before forcing a status update to the client.
+  // MAX_INTERVAL_SECONDS: Maximum time between status updates regardless of event count.
+  STATUS_UPDATE_MAX_NUM_EVENTS: 100,
+  STATUS_UPDATE_MAX_INTERVAL_SECONDS: 600,
+  // 10 minutes
+  // Prompt Text Length Validation
+  // Maximum character limits for agent and sub-agent system prompts to prevent excessive token usage.
+  // Enforced during agent configuration to ensure prompts remain focused and manageable.
+  VALIDATION_SUB_AGENT_PROMPT_MAX_CHARS: 2e3,
+  VALIDATION_AGENT_PROMPT_MAX_CHARS: 5e3,
+  // Context Fetcher HTTP Timeout
+  // Maximum time allowed for HTTP requests made by Context Fetchers (e.g., CRM lookups, external API calls).
+  // Context Fetchers automatically retrieve external data at the start of a conversation to enrich agent context.
+  CONTEXT_FETCHER_HTTP_TIMEOUT_MS_DEFAULT: 1e4
+  // 10 seconds
+};
+
 // src/types/utility.ts
 var TOOL_STATUS_VALUES = ["healthy", "unhealthy", "unknown", "needs_auth"];
 var VALID_RELATION_TYPES = ["transfer", "delegate"];
@@ -31,165 +63,165 @@ var CredentialStoreType = {
   nango: "nango"
 };
 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,
@@ -197,118 +229,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,
@@ -319,152 +351,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,
@@ -476,134 +508,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"
@@ -962,9 +994,20 @@ drizzleOrm.relations(
 );
 
 // src/validation/schemas.ts
+var {
+  AGENT_EXECUTION_TRANSFER_COUNT_MAX,
+  AGENT_EXECUTION_TRANSFER_COUNT_MIN,
+  CONTEXT_FETCHER_HTTP_TIMEOUT_MS_DEFAULT,
+  STATUS_UPDATE_MAX_INTERVAL_SECONDS,
+  STATUS_UPDATE_MAX_NUM_EVENTS,
+  SUB_AGENT_TURN_GENERATION_STEPS_MAX,
+  SUB_AGENT_TURN_GENERATION_STEPS_MIN,
+  VALIDATION_AGENT_PROMPT_MAX_CHARS,
+  VALIDATION_SUB_AGENT_PROMPT_MAX_CHARS
+} = schemaValidationDefaults;
 var StopWhenSchema = zodOpenapi.z.object({
-  transferCountIs: zodOpenapi.z.number().min(1).max(100).optional().describe("The maximum number of transfers to trigger the stop condition."),
-  stepCountIs: zodOpenapi.z.number().min(1).max(1e3).optional().describe("The maximum number of steps to trigger the stop condition.")
+  transferCountIs: zodOpenapi.z.number().min(AGENT_EXECUTION_TRANSFER_COUNT_MIN).max(AGENT_EXECUTION_TRANSFER_COUNT_MAX).optional().describe("The maximum number of transfers to trigger the stop condition."),
+  stepCountIs: zodOpenapi.z.number().min(SUB_AGENT_TURN_GENERATION_STEPS_MIN).max(SUB_AGENT_TURN_GENERATION_STEPS_MAX).optional().describe("The maximum number of steps to trigger the stop condition.")
 }).openapi("StopWhen");
 var AgentStopWhenSchema = StopWhenSchema.pick({ transferCountIs: true }).openapi(
   "AgentStopWhen"
@@ -1083,7 +1126,8 @@ createApiInsertSchema(
 );
 var AgentSelectSchema = drizzleZod.createSelectSchema(agents);
 var AgentInsertSchema = drizzleZod.createInsertSchema(agents).extend({
-  id: resourceIdSchema
+  id: resourceIdSchema,
+  name: zodOpenapi.z.string().trim().nonempty()
 });
 var AgentUpdateSchema = AgentInsertSchema.partial();
 var AgentApiSelectSchema = createApiSchema(AgentSelectSchema).openapi("Agent");
@@ -1443,7 +1487,7 @@ var FetchConfigSchema = zodOpenapi.z.object({
   body: zodOpenapi.z.record(zodOpenapi.z.string(), zodOpenapi.z.unknown()).optional(),
   transform: zodOpenapi.z.string().optional(),
   // JSONPath or JS transform function
-  timeout: zodOpenapi.z.number().min(0).optional().default(1e4).optional()
+  timeout: zodOpenapi.z.number().min(0).optional().default(CONTEXT_FETCHER_HTTP_TIMEOUT_MS_DEFAULT).optional()
 }).openapi("FetchConfig");
 zodOpenapi.z.object({
   id: zodOpenapi.z.string().min(1, "Fetch definition ID is required"),
@@ -1562,9 +1606,12 @@ var StatusComponentSchema = zodOpenapi.z.object({
 }).openapi("StatusComponent");
 var StatusUpdateSchema = zodOpenapi.z.object({
   enabled: zodOpenapi.z.boolean().optional(),
-  numEvents: zodOpenapi.z.number().min(1).max(100).optional(),
-  timeInSeconds: zodOpenapi.z.number().min(1).max(600).optional(),
-  prompt: zodOpenapi.z.string().max(2e3, "Custom prompt cannot exceed 2000 characters").optional(),
+  numEvents: zodOpenapi.z.number().min(1).max(STATUS_UPDATE_MAX_NUM_EVENTS).optional(),
+  timeInSeconds: zodOpenapi.z.number().min(1).max(STATUS_UPDATE_MAX_INTERVAL_SECONDS).optional(),
+  prompt: zodOpenapi.z.string().max(
+    VALIDATION_SUB_AGENT_PROMPT_MAX_CHARS,
+    `Custom prompt cannot exceed ${VALIDATION_SUB_AGENT_PROMPT_MAX_CHARS} characters`
+  ).optional(),
   statusComponents: zodOpenapi.z.array(StatusComponentSchema).optional()
 }).openapi("StatusUpdate");
 var CanUseItemSchema = zodOpenapi.z.object({
@@ -1595,6 +1642,7 @@ var FullAgentAgentInsertSchema = SubAgentApiInsertSchema.extend({
   dataComponents: zodOpenapi.z.array(zodOpenapi.z.string()).optional(),
   artifactComponents: zodOpenapi.z.array(zodOpenapi.z.string()).optional(),
   canTransferTo: zodOpenapi.z.array(zodOpenapi.z.string()).optional(),
+  prompt: zodOpenapi.z.string().trim().nonempty(),
   canDelegateTo: zodOpenapi.z.array(
     zodOpenapi.z.union([
       zodOpenapi.z.string(),
@@ -1623,7 +1671,10 @@ var AgentWithinContextOfProjectSchema = AgentApiInsertSchema.extend({
   statusUpdates: zodOpenapi.z.optional(StatusUpdateSchema),
   models: ModelSchema.optional(),
   stopWhen: AgentStopWhenSchema.optional(),
-  prompt: zodOpenapi.z.string().max(5e3, "Agent prompt cannot exceed 5000 characters").optional()
+  prompt: zodOpenapi.z.string().max(
+    VALIDATION_AGENT_PROMPT_MAX_CHARS,
+    `Agent prompt cannot exceed ${VALIDATION_AGENT_PROMPT_MAX_CHARS} characters`
+  ).optional()
 });
 var PaginationSchema = zodOpenapi.z.object({
   page: zodOpenapi.z.coerce.number().min(1).default(1),
@@ -2268,6 +2319,14 @@ var detectAuthenticationRequired = async ({
 };
 
 // src/client-exports.ts
+var {
+  AGENT_EXECUTION_TRANSFER_COUNT_MAX: AGENT_EXECUTION_TRANSFER_COUNT_MAX2,
+  AGENT_EXECUTION_TRANSFER_COUNT_MIN: AGENT_EXECUTION_TRANSFER_COUNT_MIN2,
+  STATUS_UPDATE_MAX_INTERVAL_SECONDS: STATUS_UPDATE_MAX_INTERVAL_SECONDS2,
+  STATUS_UPDATE_MAX_NUM_EVENTS: STATUS_UPDATE_MAX_NUM_EVENTS2,
+  VALIDATION_AGENT_PROMPT_MAX_CHARS: VALIDATION_AGENT_PROMPT_MAX_CHARS2,
+  VALIDATION_SUB_AGENT_PROMPT_MAX_CHARS: VALIDATION_SUB_AGENT_PROMPT_MAX_CHARS2
+} = schemaValidationDefaults;
 var TenantParamsSchema2 = zod.z.object({
   tenantId: zod.z.string()
 });
@@ -2399,14 +2458,14 @@ var FullAgentDefinitionSchema = AgentAgentApiInsertSchema.extend({
     }).optional()
   }).optional(),
   stopWhen: zod.z.object({
-    transferCountIs: zod.z.number().min(1).max(100).optional()
+    transferCountIs: zod.z.number().min(AGENT_EXECUTION_TRANSFER_COUNT_MIN2).max(AGENT_EXECUTION_TRANSFER_COUNT_MAX2).optional()
   }).optional(),
-  prompt: zod.z.string().max(5e3).optional(),
+  prompt: zod.z.string().max(VALIDATION_AGENT_PROMPT_MAX_CHARS2).optional(),
   statusUpdates: zod.z.object({
     enabled: zod.z.boolean().optional(),
-    numEvents: zod.z.number().min(1).max(100).optional(),
-    timeInSeconds: zod.z.number().min(1).max(600).optional(),
-    prompt: zod.z.string().max(2e3).optional(),
+    numEvents: zod.z.number().min(1).max(STATUS_UPDATE_MAX_NUM_EVENTS2).optional(),
+    timeInSeconds: zod.z.number().min(1).max(STATUS_UPDATE_MAX_INTERVAL_SECONDS2).optional(),
+    prompt: zod.z.string().max(VALIDATION_SUB_AGENT_PROMPT_MAX_CHARS2).optional(),
     statusComponents: zod.z.array(
       zod.z.object({
         type: zod.z.string(),