@inkeep/agents-core 0.1.4 → 0.1.7

package/dist/client-exports.cjs

@@ -0,0 +1,1702 @@
+'use strict';
+
+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');
+
+// src/client-exports.ts
+
+// src/types/utility.ts
+var TOOL_STATUS_VALUES = [
+  "healthy",
+  "unhealthy",
+  "unknown",
+  "disabled",
+  "needs_auth"
+];
+var VALID_RELATION_TYPES = ["transfer", "delegate"];
+var MCPTransportType = {
+  streamableHttp: "streamable_http",
+  sse: "sse"
+};
+var MCPServerType = {
+  nango: "nango",
+  generic: "generic"
+};
+var CredentialStoreType = {
+  memory: "memory",
+  keychain: "keychain",
+  nango: "nango"
+};
+var projects = sqliteCore.sqliteTable(
+  "projects",
+  {
+    tenantId: sqliteCore.text("tenant_id").notNull(),
+    id: sqliteCore.text("id").notNull(),
+    // This IS the project ID
+    name: sqliteCore.text("name").notNull(),
+    description: sqliteCore.text("description").notNull(),
+    // Project-level default model settings that can be inherited by graphs and agents
+    models: sqliteCore.text("models", { mode: "json" }).$type(),
+    // Project-level stopWhen configuration that can be inherited by graphs and agents
+    stopWhen: sqliteCore.text("stop_when", { mode: "json" }).$type(),
+    createdAt: sqliteCore.text("created_at").notNull().default(drizzleOrm.sql`CURRENT_TIMESTAMP`),
+    updatedAt: sqliteCore.text("updated_at").notNull().default(drizzleOrm.sql`CURRENT_TIMESTAMP`)
+  },
+  (table) => [sqliteCore.primaryKey({ columns: [table.tenantId, table.id] })]
+);
+var contextConfigs = sqliteCore.sqliteTable(
+  "context_configs",
+  {
+    tenantId: sqliteCore.text("tenant_id").notNull(),
+    projectId: sqliteCore.text("project_id").notNull(),
+    id: sqliteCore.text("id").notNull(),
+    name: sqliteCore.text("name").notNull(),
+    description: sqliteCore.text("description").notNull(),
+    // Developer-defined Zod schema for validating incoming request context
+    requestContextSchema: sqliteCore.blob("request_context_schema", { mode: "json" }).$type(),
+    // Stores serialized Zod schema
+    // Object mapping template keys to fetch definitions that use request context data
+    contextVariables: sqliteCore.blob("context_variables", { mode: "json" }).$type(),
+    createdAt: sqliteCore.text("created_at").notNull().default(drizzleOrm.sql`CURRENT_TIMESTAMP`),
+    updatedAt: sqliteCore.text("updated_at").notNull().default(drizzleOrm.sql`CURRENT_TIMESTAMP`)
+  },
+  (table) => [
+    sqliteCore.primaryKey({ columns: [table.tenantId, table.projectId, table.id] }),
+    sqliteCore.foreignKey({
+      columns: [table.tenantId, table.projectId],
+      foreignColumns: [projects.tenantId, projects.id],
+      name: "context_configs_project_fk"
+    }).onDelete("cascade")
+  ]
+);
+var contextCache = sqliteCore.sqliteTable(
+  "context_cache",
+  {
+    tenantId: sqliteCore.text("tenant_id").notNull(),
+    projectId: sqliteCore.text("project_id").notNull(),
+    id: sqliteCore.text("id").notNull(),
+    // Always scoped to conversation for complete data isolation
+    conversationId: sqliteCore.text("conversation_id").notNull(),
+    // Reference to the context config and specific fetch definition
+    contextConfigId: sqliteCore.text("context_config_id").notNull(),
+    contextVariableKey: sqliteCore.text("context_variable_key").notNull(),
+    // Key from contextVariables object
+    // The actual cached context data
+    value: sqliteCore.blob("value", { mode: "json" }).$type().notNull(),
+    // Request hash for cache invalidation based on context changes
+    requestHash: sqliteCore.text("request_hash"),
+    // Hash of request context that triggered this cache
+    // Metadata for monitoring and debugging
+    fetchedAt: sqliteCore.text("fetched_at").notNull(),
+    fetchSource: sqliteCore.text("fetch_source"),
+    // URL or source identifier
+    fetchDurationMs: sqliteCore.integer("fetch_duration_ms"),
+    createdAt: sqliteCore.text("created_at").notNull().default(drizzleOrm.sql`CURRENT_TIMESTAMP`),
+    updatedAt: sqliteCore.text("updated_at").notNull().default(drizzleOrm.sql`CURRENT_TIMESTAMP`)
+  },
+  (table) => [
+    sqliteCore.primaryKey({ columns: [table.tenantId, table.projectId, table.id] }),
+    sqliteCore.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(
+      table.conversationId,
+      table.contextConfigId,
+      table.contextVariableKey
+    )
+  ]
+);
+var agents = sqliteCore.sqliteTable(
+  "agents",
+  {
+    tenantId: sqliteCore.text("tenant_id").notNull(),
+    projectId: sqliteCore.text("project_id").notNull(),
+    id: sqliteCore.text("id").notNull(),
+    name: sqliteCore.text("name").notNull(),
+    description: sqliteCore.text("description").notNull(),
+    prompt: sqliteCore.text("prompt").notNull(),
+    conversationHistoryConfig: sqliteCore.text("conversation_history_config", {
+      mode: "json"
+    }).$type(),
+    models: sqliteCore.text("models", { mode: "json" }).$type(),
+    // Agent-level stopWhen configuration (inherited from project)
+    stopWhen: sqliteCore.text("stop_when", { mode: "json" }).$type(),
+    createdAt: sqliteCore.text("created_at").notNull().default(drizzleOrm.sql`CURRENT_TIMESTAMP`),
+    updatedAt: sqliteCore.text("updated_at").notNull().default(drizzleOrm.sql`CURRENT_TIMESTAMP`)
+  },
+  (table) => [
+    sqliteCore.primaryKey({ columns: [table.tenantId, table.projectId, table.id] }),
+    sqliteCore.foreignKey({
+      columns: [table.tenantId, table.projectId],
+      foreignColumns: [projects.tenantId, projects.id],
+      name: "agents_project_fk"
+    }).onDelete("cascade")
+  ]
+);
+var agentRelations = sqliteCore.sqliteTable(
+  "agent_relations",
+  {
+    tenantId: sqliteCore.text("tenant_id").notNull(),
+    projectId: sqliteCore.text("project_id").notNull(),
+    id: sqliteCore.text("id").notNull(),
+    graphId: sqliteCore.text("graph_id").notNull(),
+    sourceAgentId: sqliteCore.text("source_agent_id").notNull(),
+    // For internal relationships
+    targetAgentId: sqliteCore.text("target_agent_id"),
+    // For external relationships
+    externalAgentId: sqliteCore.text("external_agent_id"),
+    relationType: sqliteCore.text("relation_type"),
+    // 'transfer' | 'delegate'
+    createdAt: sqliteCore.text("created_at").notNull().default(drizzleOrm.sql`CURRENT_TIMESTAMP`),
+    updatedAt: sqliteCore.text("updated_at").notNull().default(drizzleOrm.sql`CURRENT_TIMESTAMP`)
+  },
+  (table) => [
+    sqliteCore.primaryKey({ columns: [table.tenantId, table.projectId, table.id] }),
+    sqliteCore.foreignKey({
+      columns: [table.tenantId, table.projectId],
+      foreignColumns: [projects.tenantId, projects.id],
+      name: "agent_relations_project_fk"
+    }).onDelete("cascade")
+  ]
+);
+var externalAgents = sqliteCore.sqliteTable(
+  "external_agents",
+  {
+    tenantId: sqliteCore.text("tenant_id").notNull(),
+    projectId: sqliteCore.text("project_id").notNull(),
+    id: sqliteCore.text("id").notNull(),
+    name: sqliteCore.text("name").notNull(),
+    description: sqliteCore.text("description").notNull(),
+    baseUrl: sqliteCore.text("base_url").notNull(),
+    // A2A endpoint URL
+    credentialReferenceId: sqliteCore.text("credential_reference_id"),
+    headers: sqliteCore.blob("headers", { mode: "json" }).$type(),
+    createdAt: sqliteCore.text("created_at").notNull().default(drizzleOrm.sql`CURRENT_TIMESTAMP`),
+    updatedAt: sqliteCore.text("updated_at").notNull().default(drizzleOrm.sql`CURRENT_TIMESTAMP`)
+  },
+  (table) => [
+    sqliteCore.primaryKey({ columns: [table.tenantId, table.projectId, table.id] }),
+    sqliteCore.foreignKey({
+      columns: [table.tenantId, table.projectId],
+      foreignColumns: [projects.tenantId, projects.id],
+      name: "external_agents_project_fk"
+    }).onDelete("cascade"),
+    sqliteCore.foreignKey({
+      columns: [table.tenantId, table.projectId, table.credentialReferenceId],
+      foreignColumns: [
+        credentialReferences.tenantId,
+        credentialReferences.projectId,
+        credentialReferences.id
+      ],
+      name: "external_agents_credential_reference_fk"
+    }).onDelete("set null")
+  ]
+);
+var agentGraph = sqliteCore.sqliteTable(
+  "agent_graph",
+  {
+    tenantId: sqliteCore.text("tenant_id").notNull(),
+    projectId: sqliteCore.text("project_id").notNull(),
+    id: sqliteCore.text("id").notNull(),
+    name: sqliteCore.text("name").notNull(),
+    description: sqliteCore.text("description"),
+    defaultAgentId: sqliteCore.text("default_agent_id").notNull(),
+    // Reference to shared context configuration for all agents in this graph
+    contextConfigId: sqliteCore.text("context_config_id"),
+    // Graph-level model settingsuration that can be inherited by agents
+    models: sqliteCore.text("models", { mode: "json" }).$type(),
+    // Status updates configuration for intelligent progress summaries
+    statusUpdates: sqliteCore.text("status_updates", { mode: "json" }).$type(),
+    // Graph-level prompt that can be used as additional context for agents
+    graphPrompt: sqliteCore.text("graph_prompt"),
+    // Graph-level stopWhen configuration that can be inherited by agents
+    stopWhen: sqliteCore.text("stop_when", { mode: "json" }).$type(),
+    createdAt: sqliteCore.text("created_at").notNull().default(drizzleOrm.sql`CURRENT_TIMESTAMP`),
+    updatedAt: sqliteCore.text("updated_at").notNull().default(drizzleOrm.sql`CURRENT_TIMESTAMP`)
+  },
+  (table) => [
+    sqliteCore.primaryKey({ columns: [table.tenantId, table.projectId, table.id] }),
+    sqliteCore.foreignKey({
+      columns: [table.tenantId, table.projectId],
+      foreignColumns: [projects.tenantId, projects.id],
+      name: "agent_graph_project_fk"
+    }).onDelete("cascade")
+  ]
+);
+var tasks = sqliteCore.sqliteTable(
+  "tasks",
+  {
+    tenantId: sqliteCore.text("tenant_id").notNull(),
+    projectId: sqliteCore.text("project_id").notNull(),
+    id: sqliteCore.text("id").notNull(),
+    contextId: sqliteCore.text("context_id").notNull(),
+    status: sqliteCore.text("status").notNull(),
+    metadata: sqliteCore.blob("metadata", { mode: "json" }).$type(),
+    agentId: sqliteCore.text("agent_id").notNull(),
+    createdAt: sqliteCore.text("created_at").notNull().default(drizzleOrm.sql`CURRENT_TIMESTAMP`),
+    updatedAt: sqliteCore.text("updated_at").notNull().default(drizzleOrm.sql`CURRENT_TIMESTAMP`)
+  },
+  (table) => [
+    sqliteCore.primaryKey({ columns: [table.tenantId, table.projectId, table.id] }),
+    sqliteCore.foreignKey({
+      columns: [table.tenantId, table.projectId],
+      foreignColumns: [projects.tenantId, projects.id],
+      name: "tasks_project_fk"
+    }).onDelete("cascade")
+  ]
+);
+var taskRelations = sqliteCore.sqliteTable(
+  "task_relations",
+  {
+    tenantId: sqliteCore.text("tenant_id").notNull(),
+    projectId: sqliteCore.text("project_id").notNull(),
+    id: sqliteCore.text("id").notNull(),
+    parentTaskId: sqliteCore.text("parent_task_id").notNull(),
+    childTaskId: sqliteCore.text("child_task_id").notNull(),
+    relationType: sqliteCore.text("relation_type").default("parent_child"),
+    // Could be extended for other relation types
+    createdAt: sqliteCore.text("created_at").notNull().default(drizzleOrm.sql`CURRENT_TIMESTAMP`),
+    updatedAt: sqliteCore.text("updated_at").notNull().default(drizzleOrm.sql`CURRENT_TIMESTAMP`)
+  },
+  (table) => [
+    sqliteCore.primaryKey({ columns: [table.tenantId, table.projectId, table.id] }),
+    sqliteCore.foreignKey({
+      columns: [table.tenantId, table.projectId],
+      foreignColumns: [projects.tenantId, projects.id],
+      name: "task_relations_project_fk"
+    }).onDelete("cascade")
+  ]
+);
+var dataComponents = sqliteCore.sqliteTable(
+  "data_components",
+  {
+    tenantId: sqliteCore.text("tenant_id").notNull(),
+    projectId: sqliteCore.text("project_id").notNull(),
+    id: sqliteCore.text("id").notNull(),
+    name: sqliteCore.text("name").notNull(),
+    description: sqliteCore.text("description").notNull(),
+    props: sqliteCore.blob("props", { mode: "json" }).$type(),
+    createdAt: sqliteCore.text("created_at").notNull().default(drizzleOrm.sql`CURRENT_TIMESTAMP`),
+    updatedAt: sqliteCore.text("updated_at").notNull().default(drizzleOrm.sql`CURRENT_TIMESTAMP`)
+  },
+  (table) => [
+    sqliteCore.primaryKey({ columns: [table.tenantId, table.projectId, table.id] }),
+    sqliteCore.foreignKey({
+      columns: [table.tenantId, table.projectId],
+      foreignColumns: [projects.tenantId, projects.id],
+      name: "data_components_project_fk"
+    }).onDelete("cascade")
+  ]
+);
+var agentDataComponents = sqliteCore.sqliteTable(
+  "agent_data_components",
+  {
+    tenantId: sqliteCore.text("tenant_id").notNull(),
+    projectId: sqliteCore.text("project_id").notNull(),
+    id: sqliteCore.text("id").notNull(),
+    agentId: sqliteCore.text("agent_id").notNull(),
+    dataComponentId: sqliteCore.text("data_component_id").notNull(),
+    createdAt: sqliteCore.text("created_at").notNull().default(drizzleOrm.sql`CURRENT_TIMESTAMP`)
+  },
+  (table) => [
+    sqliteCore.primaryKey({ columns: [table.tenantId, table.projectId, table.id] }),
+    // Foreign key constraint to projects table
+    sqliteCore.foreignKey({
+      columns: [table.tenantId, table.projectId],
+      foreignColumns: [projects.tenantId, projects.id],
+      name: "agent_data_components_project_fk"
+    }).onDelete("cascade"),
+    // Foreign key constraint to agents table
+    sqliteCore.foreignKey({
+      columns: [table.tenantId, table.projectId, table.agentId],
+      foreignColumns: [agents.tenantId, agents.projectId, agents.id],
+      name: "agent_data_components_agent_fk"
+    }).onDelete("cascade"),
+    // Foreign key constraint to data_components table
+    sqliteCore.foreignKey({
+      columns: [table.tenantId, table.projectId, table.dataComponentId],
+      foreignColumns: [dataComponents.tenantId, dataComponents.projectId, dataComponents.id],
+      name: "agent_data_components_data_component_fk"
+    }).onDelete("cascade")
+  ]
+);
+var artifactComponents = sqliteCore.sqliteTable(
+  "artifact_components",
+  {
+    tenantId: sqliteCore.text("tenant_id").notNull(),
+    projectId: sqliteCore.text("project_id").notNull(),
+    id: sqliteCore.text("id").notNull(),
+    name: sqliteCore.text("name").notNull(),
+    description: sqliteCore.text("description").notNull(),
+    summaryProps: sqliteCore.blob("summary_props", { mode: "json" }).$type(),
+    fullProps: sqliteCore.blob("full_props", { mode: "json" }).$type(),
+    createdAt: sqliteCore.text("created_at").notNull().default(drizzleOrm.sql`CURRENT_TIMESTAMP`),
+    updatedAt: sqliteCore.text("updated_at").notNull().default(drizzleOrm.sql`CURRENT_TIMESTAMP`)
+  },
+  (table) => [
+    sqliteCore.primaryKey({ columns: [table.tenantId, table.projectId, table.id] }),
+    sqliteCore.foreignKey({
+      columns: [table.tenantId, table.projectId],
+      foreignColumns: [projects.tenantId, projects.id],
+      name: "artifact_components_project_fk"
+    }).onDelete("cascade")
+  ]
+);
+var agentArtifactComponents = sqliteCore.sqliteTable(
+  "agent_artifact_components",
+  {
+    tenantId: sqliteCore.text("tenant_id").notNull(),
+    projectId: sqliteCore.text("project_id").notNull(),
+    id: sqliteCore.text("id").notNull(),
+    agentId: sqliteCore.text("agent_id").notNull(),
+    artifactComponentId: sqliteCore.text("artifact_component_id").notNull(),
+    createdAt: sqliteCore.text("created_at").notNull().default(drizzleOrm.sql`CURRENT_TIMESTAMP`)
+  },
+  (table) => [
+    sqliteCore.primaryKey({ columns: [table.tenantId, table.projectId, table.id] }),
+    // Foreign key constraint to projects table
+    sqliteCore.foreignKey({
+      columns: [table.tenantId, table.projectId],
+      foreignColumns: [projects.tenantId, projects.id],
+      name: "agent_artifact_components_project_fk"
+    }).onDelete("cascade"),
+    // Foreign key constraint to agents table
+    sqliteCore.foreignKey({
+      columns: [table.tenantId, table.projectId, table.agentId],
+      foreignColumns: [agents.tenantId, agents.projectId, agents.id],
+      name: "agent_artifact_components_agent_fk"
+    }).onDelete("cascade"),
+    // Foreign key constraint to artifact_components table
+    sqliteCore.foreignKey({
+      columns: [table.tenantId, table.projectId, table.artifactComponentId],
+      foreignColumns: [
+        artifactComponents.tenantId,
+        artifactComponents.projectId,
+        artifactComponents.id
+      ],
+      name: "agent_artifact_components_artifact_component_fk"
+    }).onDelete("cascade")
+  ]
+);
+var tools = sqliteCore.sqliteTable(
+  "tools",
+  {
+    tenantId: sqliteCore.text("tenant_id").notNull(),
+    projectId: sqliteCore.text("project_id").notNull(),
+    id: sqliteCore.text("id").notNull(),
+    name: sqliteCore.text("name").notNull(),
+    // Enhanced MCP configuration
+    config: sqliteCore.blob("config", { mode: "json" }).$type().notNull(),
+    credentialReferenceId: sqliteCore.text("credential_reference_id"),
+    headers: sqliteCore.blob("headers", { mode: "json" }).$type(),
+    // Image URL for custom tool icon (supports regular URLs and base64 encoded images)
+    imageUrl: sqliteCore.text("image_url"),
+    // Server capabilities and status
+    capabilities: sqliteCore.blob("capabilities", { mode: "json" }).$type(),
+    // Connection health and monitoring
+    status: sqliteCore.text("status").notNull().default("unknown"),
+    lastHealthCheck: sqliteCore.text("last_health_check"),
+    lastError: sqliteCore.text("last_error"),
+    // Tool discovery cache
+    availableTools: sqliteCore.blob("available_tools", { mode: "json" }).$type(),
+    lastToolsSync: sqliteCore.text("last_tools_sync"),
+    createdAt: sqliteCore.text("created_at").notNull().default(drizzleOrm.sql`CURRENT_TIMESTAMP`),
+    updatedAt: sqliteCore.text("updated_at").notNull().default(drizzleOrm.sql`CURRENT_TIMESTAMP`)
+  },
+  (table) => [
+    sqliteCore.primaryKey({ columns: [table.tenantId, table.projectId, table.id] }),
+    sqliteCore.foreignKey({
+      columns: [table.tenantId, table.projectId],
+      foreignColumns: [projects.tenantId, projects.id],
+      name: "tools_project_fk"
+    }).onDelete("cascade")
+  ]
+);
+var agentToolRelations = sqliteCore.sqliteTable(
+  "agent_tool_relations",
+  {
+    tenantId: sqliteCore.text("tenant_id").notNull(),
+    projectId: sqliteCore.text("project_id").notNull(),
+    id: sqliteCore.text("id").notNull(),
+    agentId: sqliteCore.text("agent_id").notNull(),
+    toolId: sqliteCore.text("tool_id").notNull(),
+    selectedTools: sqliteCore.blob("selected_tools", { mode: "json" }).$type(),
+    createdAt: sqliteCore.text("created_at").notNull().default(drizzleOrm.sql`CURRENT_TIMESTAMP`),
+    updatedAt: sqliteCore.text("updated_at").notNull().default(drizzleOrm.sql`CURRENT_TIMESTAMP`)
+  },
+  (table) => [
+    sqliteCore.primaryKey({ columns: [table.tenantId, table.projectId, table.id] }),
+    // Foreign key constraint to projects table
+    sqliteCore.foreignKey({
+      columns: [table.tenantId, table.projectId],
+      foreignColumns: [projects.tenantId, projects.id],
+      name: "agent_tool_relations_project_fk"
+    }).onDelete("cascade"),
+    // Foreign key constraint to agents table
+    sqliteCore.foreignKey({
+      columns: [table.tenantId, table.projectId, table.agentId],
+      foreignColumns: [agents.tenantId, agents.projectId, agents.id],
+      name: "agent_tool_relations_agent_fk"
+    }).onDelete("cascade"),
+    // Foreign key constraint to tools table
+    sqliteCore.foreignKey({
+      columns: [table.tenantId, table.projectId, table.toolId],
+      foreignColumns: [tools.tenantId, tools.projectId, tools.id],
+      name: "agent_tool_relations_tool_fk"
+    }).onDelete("cascade")
+  ]
+);
+var conversations = sqliteCore.sqliteTable(
+  "conversations",
+  {
+    tenantId: sqliteCore.text("tenant_id").notNull(),
+    projectId: sqliteCore.text("project_id").notNull(),
+    id: sqliteCore.text("id").notNull(),
+    userId: sqliteCore.text("user_id"),
+    activeAgentId: sqliteCore.text("active_agent_id").notNull(),
+    title: sqliteCore.text("title"),
+    lastContextResolution: sqliteCore.text("last_context_resolution"),
+    metadata: sqliteCore.blob("metadata", { mode: "json" }).$type(),
+    createdAt: sqliteCore.text("created_at").notNull().default(drizzleOrm.sql`CURRENT_TIMESTAMP`),
+    updatedAt: sqliteCore.text("updated_at").notNull().default(drizzleOrm.sql`CURRENT_TIMESTAMP`)
+  },
+  (table) => [
+    sqliteCore.primaryKey({ columns: [table.tenantId, table.projectId, table.id] }),
+    sqliteCore.foreignKey({
+      columns: [table.tenantId, table.projectId],
+      foreignColumns: [projects.tenantId, projects.id],
+      name: "conversations_project_fk"
+    }).onDelete("cascade")
+  ]
+);
+var messages = sqliteCore.sqliteTable(
+  "messages",
+  {
+    tenantId: sqliteCore.text("tenant_id").notNull(),
+    projectId: sqliteCore.text("project_id").notNull(),
+    id: sqliteCore.text("id").notNull(),
+    conversationId: sqliteCore.text("conversation_id").notNull(),
+    // Role mapping: user, agent, system (unified for both formats)
+    role: sqliteCore.text("role").notNull(),
+    // 'user' | 'agent' | 'system'
+    // Agent sender/recipient tracking (nullable - only populated when relevant)
+    fromAgentId: sqliteCore.text("from_agent_id"),
+    // Populated when message is from an agent
+    toAgentId: sqliteCore.text("to_agent_id"),
+    // Populated when message is directed to a specific agent (e.g., transfers/delegations)
+    // External agent sender tracking
+    fromExternalAgentId: sqliteCore.text("from_external_agent_id"),
+    // Populated when message is directed from an external agent
+    // External agent recipient tracking
+    toExternalAgentId: sqliteCore.text("to_external_agent_id"),
+    // Populated when message is directed to an external agent
+    // Message content stored as JSON to support both formats
+    content: sqliteCore.blob("content", { mode: "json" }).$type().notNull(),
+    // Message classification and filtering
+    visibility: sqliteCore.text("visibility").notNull().default("user-facing"),
+    // 'user-facing' | 'internal' | 'system' | 'external'
+    messageType: sqliteCore.text("message_type").notNull().default("chat"),
+    // 'chat' | 'a2a-request' | 'a2a-response' | 'task-update' | 'tool-call'
+    // Legacy agent association (consider deprecating in favor of fromAgentId/toAgentId)
+    agentId: sqliteCore.text("agent_id"),
+    taskId: sqliteCore.text("task_id"),
+    parentMessageId: sqliteCore.text("parent_message_id"),
+    // Remove self-reference constraint here
+    // A2A specific fields
+    a2aTaskId: sqliteCore.text("a2a_task_id"),
+    // Links to A2A task when relevant
+    a2aSessionId: sqliteCore.text("a2a_session_id"),
+    // A2A session identifier
+    // Metadata for extensions
+    metadata: sqliteCore.blob("metadata", { mode: "json" }).$type(),
+    createdAt: sqliteCore.text("created_at").notNull().default(drizzleOrm.sql`CURRENT_TIMESTAMP`),
+    updatedAt: sqliteCore.text("updated_at").notNull().default(drizzleOrm.sql`CURRENT_TIMESTAMP`)
+  },
+  (table) => [
+    sqliteCore.primaryKey({ columns: [table.tenantId, table.projectId, table.id] }),
+    sqliteCore.foreignKey({
+      columns: [table.tenantId, table.projectId],
+      foreignColumns: [projects.tenantId, projects.id],
+      name: "messages_project_fk"
+    }).onDelete("cascade")
+  ]
+);
+var ledgerArtifacts = sqliteCore.sqliteTable(
+  "ledger_artifacts",
+  {
+    // Primary identifier (maps to `artifactId`)
+    tenantId: sqliteCore.text("tenant_id").notNull(),
+    projectId: sqliteCore.text("project_id").notNull(),
+    id: sqliteCore.text("id").notNull(),
+    // Links
+    taskId: sqliteCore.text("task_id"),
+    contextId: sqliteCore.text("context_id").notNull(),
+    // Core Artifact fields
+    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(),
+    // Extra ledger information (not part of the Artifact spec – kept optional)
+    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"),
+    // Timestamps
+    createdAt: sqliteCore.text("created_at").notNull().default(drizzleOrm.sql`CURRENT_TIMESTAMP`),
+    updatedAt: sqliteCore.text("updated_at").notNull().default(drizzleOrm.sql`CURRENT_TIMESTAMP`)
+  },
+  (table) => [
+    sqliteCore.primaryKey({ columns: [table.tenantId, table.projectId, table.id] }),
+    sqliteCore.foreignKey({
+      columns: [table.tenantId, table.projectId],
+      foreignColumns: [projects.tenantId, projects.id],
+      name: "ledger_artifacts_project_fk"
+    }).onDelete("cascade")
+  ]
+);
+var apiKeys = sqliteCore.sqliteTable(
+  "api_keys",
+  {
+    id: sqliteCore.text("id").primaryKey(),
+    tenantId: sqliteCore.text("tenant_id").notNull(),
+    projectId: sqliteCore.text("project_id").notNull(),
+    graphId: sqliteCore.text("graph_id").notNull(),
+    publicId: sqliteCore.text("public_id").notNull().unique(),
+    // Public ID for O(1) lookup (e.g., "abc123def456")
+    keyHash: sqliteCore.text("key_hash").notNull(),
+    // Hashed API key (never store plaintext)
+    keyPrefix: sqliteCore.text("key_prefix").notNull(),
+    // First 8 chars for identification (e.g., "sk_live_abc...")
+    lastUsedAt: sqliteCore.text("last_used_at"),
+    expiresAt: sqliteCore.text("expires_at"),
+    createdAt: sqliteCore.text("created_at").notNull().default(drizzleOrm.sql`CURRENT_TIMESTAMP`),
+    updatedAt: sqliteCore.text("updated_at").notNull().default(drizzleOrm.sql`CURRENT_TIMESTAMP`)
+  },
+  (t) => [
+    sqliteCore.foreignKey({
+      columns: [t.tenantId, t.projectId],
+      foreignColumns: [projects.tenantId, projects.id],
+      name: "api_keys_project_fk"
+    }).onDelete("cascade"),
+    sqliteCore.foreignKey({
+      columns: [t.tenantId, t.projectId, t.graphId],
+      foreignColumns: [agentGraph.tenantId, agentGraph.projectId, agentGraph.id],
+      name: "api_keys_graph_fk"
+    }).onDelete("cascade"),
+    sqliteCore.index("api_keys_tenant_graph_idx").on(t.tenantId, t.graphId),
+    sqliteCore.index("api_keys_prefix_idx").on(t.keyPrefix),
+    sqliteCore.index("api_keys_public_id_idx").on(t.publicId)
+  ]
+);
+var credentialReferences = sqliteCore.sqliteTable(
+  "credential_references",
+  {
+    tenantId: sqliteCore.text("tenant_id").notNull(),
+    projectId: sqliteCore.text("project_id").notNull(),
+    id: sqliteCore.text("id").notNull(),
+    type: sqliteCore.text("type").notNull(),
+    // Implementation type: 'keychain', 'nango', 'memory', etc.
+    credentialStoreId: sqliteCore.text("credential_store_id").notNull(),
+    // Maps to framework.getCredentialStore(id)
+    retrievalParams: sqliteCore.blob("retrieval_params", { mode: "json" }).$type(),
+    createdAt: sqliteCore.text("created_at").notNull().default(drizzleOrm.sql`CURRENT_TIMESTAMP`),
+    updatedAt: sqliteCore.text("updated_at").notNull().default(drizzleOrm.sql`CURRENT_TIMESTAMP`)
+  },
+  (t) => [
+    sqliteCore.primaryKey({ columns: [t.tenantId, t.projectId, t.id] }),
+    sqliteCore.foreignKey({
+      columns: [t.tenantId, t.projectId],
+      foreignColumns: [projects.tenantId, projects.id],
+      name: "credential_references_project_fk"
+    }).onDelete("cascade")
+  ]
+);
+sqliteCore.index("ledger_artifacts_task_id_idx").on(
+  ledgerArtifacts.taskId
+);
+sqliteCore.index("ledger_artifacts_context_id_idx").on(
+  ledgerArtifacts.contextId
+);
+sqliteCore.unique(
+  "ledger_artifacts_task_context_name_unique"
+).on(ledgerArtifacts.taskId, ledgerArtifacts.contextId, ledgerArtifacts.name);
+drizzleOrm.relations(tasks, ({ one, many }) => ({
+  // A task belongs to one project
+  project: one(projects, {
+    fields: [tasks.tenantId, tasks.projectId],
+    references: [projects.tenantId, projects.id]
+  }),
+  // A task can have many parent relationships (where it's the child)
+  parentRelations: many(taskRelations, {
+    relationName: "childTask"
+  }),
+  // A task can have many child relationships (where it's the parent)
+  childRelations: many(taskRelations, {
+    relationName: "parentTask"
+  }),
+  // A task belongs to one agent
+  agent: one(agents, {
+    fields: [tasks.agentId],
+    references: [agents.id]
+  }),
+  // A task can have many messages associated with it
+  messages: many(messages)
+}));
+drizzleOrm.relations(projects, ({ many }) => ({
+  // A project can have many agents
+  agents: many(agents),
+  // A project can have many agent graphs
+  agentGraphs: many(agentGraph),
+  // A project can have many tools
+  tools: many(tools),
+  // A project can have many context configs
+  contextConfigs: many(contextConfigs),
+  // A project can have many external agents
+  externalAgents: many(externalAgents),
+  // A project can have many conversations
+  conversations: many(conversations),
+  // A project can have many tasks
+  tasks: many(tasks)
+}));
+drizzleOrm.relations(taskRelations, ({ one }) => ({
+  // Each relation has one parent task
+  parentTask: one(tasks, {
+    fields: [taskRelations.parentTaskId],
+    references: [tasks.id],
+    relationName: "parentTask"
+  }),
+  // Each relation has one child task
+  childTask: one(tasks, {
+    fields: [taskRelations.childTaskId],
+    references: [tasks.id],
+    relationName: "childTask"
+  })
+}));
+drizzleOrm.relations(contextConfigs, ({ many, one }) => ({
+  // A context config belongs to one project
+  project: one(projects, {
+    fields: [contextConfigs.tenantId, contextConfigs.projectId],
+    references: [projects.tenantId, projects.id]
+  }),
+  // A context config can be used by many agent graphs
+  graphs: many(agentGraph),
+  // A context config can have many cached entries
+  cache: many(contextCache)
+}));
+drizzleOrm.relations(contextCache, ({ one }) => ({
+  // Each cache entry belongs to one context config
+  contextConfig: one(contextConfigs, {
+    fields: [contextCache.contextConfigId],
+    references: [contextConfigs.id]
+  })
+}));
+drizzleOrm.relations(agents, ({ many, one }) => ({
+  // A context config belongs to one project
+  project: one(projects, {
+    fields: [agents.tenantId, agents.projectId],
+    references: [projects.tenantId, projects.id]
+  }),
+  // An agent can have many tasks
+  tasks: many(tasks),
+  // An agent can be the default agent for many graphs
+  defaultForGraphs: many(agentGraph),
+  // Agent relation tracking
+  sourceRelations: many(agentRelations, {
+    relationName: "sourceRelations"
+  }),
+  targetRelations: many(agentRelations, {
+    relationName: "targetRelations"
+  }),
+  // Message tracking relations
+  sentMessages: many(messages, {
+    relationName: "sentMessages"
+  }),
+  receivedMessages: many(messages, {
+    relationName: "receivedMessages"
+  }),
+  // Legacy message association (consider deprecating)
+  associatedMessages: many(messages, {
+    relationName: "associatedAgent"
+  }),
+  toolRelations: many(agentToolRelations)
+}));
+drizzleOrm.relations(agentGraph, ({ one }) => ({
+  // An agent graph belongs to one project
+  project: one(projects, {
+    fields: [agentGraph.tenantId, agentGraph.projectId],
+    references: [projects.tenantId, projects.id]
+  }),
+  // An agent graph belongs to one default agent
+  defaultAgent: one(agents, {
+    fields: [agentGraph.defaultAgentId],
+    references: [agents.id]
+  }),
+  // An agent graph can reference one context config
+  contextConfig: one(contextConfigs, {
+    fields: [agentGraph.contextConfigId],
+    references: [contextConfigs.id]
+  })
+}));
+drizzleOrm.relations(externalAgents, ({ one, many }) => ({
+  // An external agent belongs to one project
+  project: one(projects, {
+    fields: [externalAgents.tenantId, externalAgents.projectId],
+    references: [projects.tenantId, projects.id]
+  }),
+  // An external agent can be referenced by many agent relations
+  agentRelations: many(agentRelations),
+  // An external agent may have one credential reference
+  credentialReference: one(credentialReferences, {
+    fields: [externalAgents.credentialReferenceId],
+    references: [credentialReferences.id]
+  })
+}));
+drizzleOrm.relations(apiKeys, ({ one }) => ({
+  // An API key belongs to one project
+  project: one(projects, {
+    fields: [apiKeys.tenantId, apiKeys.projectId],
+    references: [projects.tenantId, projects.id]
+  }),
+  // An API key belongs to one tenant and graph
+  graph: one(agentGraph, {
+    fields: [apiKeys.graphId],
+    references: [agentGraph.id]
+  })
+}));
+drizzleOrm.relations(agentToolRelations, ({ one }) => ({
+  // An agent-tool relation belongs to one agent
+  agent: one(agents, {
+    fields: [agentToolRelations.agentId],
+    references: [agents.id]
+  }),
+  // An agent-tool relation belongs to one tool
+  tool: one(tools, {
+    fields: [agentToolRelations.toolId],
+    references: [tools.id]
+  })
+}));
+drizzleOrm.relations(credentialReferences, ({ many }) => ({
+  tools: many(tools)
+}));
+drizzleOrm.relations(tools, ({ one, many }) => ({
+  // A tool belongs to one project
+  project: one(projects, {
+    fields: [tools.tenantId, tools.projectId],
+    references: [projects.tenantId, projects.id]
+  }),
+  // A tool can be used by many agents through agent-tool relations
+  agentRelations: many(agentToolRelations),
+  // A tool may have one credential reference
+  credentialReference: one(credentialReferences, {
+    fields: [tools.credentialReferenceId],
+    references: [credentialReferences.id]
+  })
+}));
+drizzleOrm.relations(conversations, ({ one, many }) => ({
+  // A conversation belongs to one project
+  project: one(projects, {
+    fields: [conversations.tenantId, conversations.projectId],
+    references: [projects.tenantId, projects.id]
+  }),
+  // A conversation has many messages
+  messages: many(messages),
+  // A conversation has one active agent
+  activeAgent: one(agents, {
+    fields: [conversations.activeAgentId],
+    references: [agents.id]
+  })
+}));
+drizzleOrm.relations(messages, ({ one, many }) => ({
+  // A message belongs to one conversation
+  conversation: one(conversations, {
+    fields: [messages.conversationId],
+    references: [conversations.id]
+  }),
+  // Legacy agent association (consider deprecating)
+  agent: one(agents, {
+    fields: [messages.agentId],
+    references: [agents.id],
+    relationName: "associatedAgent"
+  }),
+  // Sender tracking relations
+  fromAgent: one(agents, {
+    fields: [messages.fromAgentId],
+    references: [agents.id],
+    relationName: "sentMessages"
+  }),
+  // Recipient tracking relations
+  toAgent: one(agents, {
+    fields: [messages.toAgentId],
+    references: [agents.id],
+    relationName: "receivedMessages"
+  }),
+  // External agent sender tracking relations
+  fromExternalAgent: one(externalAgents, {
+    fields: [messages.fromExternalAgentId],
+    references: [externalAgents.id],
+    relationName: "receivedExternalMessages"
+  }),
+  // External agent recipient tracking relations
+  toExternalAgent: one(externalAgents, {
+    fields: [messages.toExternalAgentId],
+    references: [externalAgents.id],
+    relationName: "sentExternalMessages"
+  }),
+  // A message may be associated with a task
+  task: one(tasks, {
+    fields: [messages.taskId],
+    references: [tasks.id]
+  }),
+  // A message may have a parent message (for threading)
+  parentMessage: one(messages, {
+    fields: [messages.parentMessageId],
+    references: [messages.id],
+    relationName: "parentChild"
+  }),
+  // A message may have child messages
+  childMessages: many(messages, {
+    relationName: "parentChild"
+  })
+}));
+drizzleOrm.relations(artifactComponents, ({ many }) => ({
+  // An artifact component can be associated with many agents
+  agentRelations: many(agentArtifactComponents)
+}));
+drizzleOrm.relations(agentArtifactComponents, ({ one }) => ({
+  // An agent-artifact component relation belongs to one agent
+  agent: one(agents, {
+    fields: [agentArtifactComponents.agentId],
+    references: [agents.id]
+  }),
+  // An agent-artifact component relation belongs to one artifact component
+  artifactComponent: one(artifactComponents, {
+    fields: [agentArtifactComponents.artifactComponentId],
+    references: [artifactComponents.id]
+  })
+}));
+drizzleOrm.relations(agentRelations, ({ one }) => ({
+  // An agent relation belongs to one graph
+  graph: one(agentGraph, {
+    fields: [agentRelations.graphId],
+    references: [agentGraph.id]
+  }),
+  // An agent relation has one source agent
+  sourceAgent: one(agents, {
+    fields: [agentRelations.sourceAgentId],
+    references: [agents.id],
+    relationName: "sourceRelations"
+  }),
+  // An agent relation may have one target agent (for internal relations)
+  targetAgent: one(agents, {
+    fields: [agentRelations.targetAgentId],
+    references: [agents.id],
+    relationName: "targetRelations"
+  }),
+  // An agent relation may have one external agent (for external relations)
+  externalAgent: one(externalAgents, {
+    fields: [agentRelations.externalAgentId],
+    references: [externalAgents.id]
+  })
+}));
+
+// src/validation/schemas.ts
+var StopWhenSchema = zodOpenapi.z.object({
+  transferCountIs: zodOpenapi.z.number().min(1).max(100).optional(),
+  stepCountIs: zodOpenapi.z.number().min(1).max(1e3).optional()
+});
+var GraphStopWhenSchema = StopWhenSchema.pick({ transferCountIs: true });
+var AgentStopWhenSchema = StopWhenSchema.pick({ stepCountIs: true });
+var MIN_ID_LENGTH = 1;
+var MAX_ID_LENGTH = 255;
+var URL_SAFE_ID_PATTERN = /^[a-zA-Z0-9\-_.]+$/;
+var resourceIdSchema = zodOpenapi.z.string().min(MIN_ID_LENGTH).max(MAX_ID_LENGTH).regex(URL_SAFE_ID_PATTERN, {
+  message: "ID must contain only letters, numbers, hyphens, underscores, and dots"
+}).openapi({
+  description: "Resource identifier",
+  example: "resource_789"
+});
+var ModelSettingsSchema = zodOpenapi.z.object({
+  model: zodOpenapi.z.string().optional(),
+  providerOptions: zodOpenapi.z.record(zodOpenapi.z.string(), zodOpenapi.z.unknown()).optional()
+});
+var ModelSchema = zodOpenapi.z.object({
+  base: ModelSettingsSchema.optional(),
+  structuredOutput: ModelSettingsSchema.optional(),
+  summarizer: ModelSettingsSchema.optional()
+});
+var ProjectModelSchema = zodOpenapi.z.object({
+  base: ModelSettingsSchema,
+  structuredOutput: ModelSettingsSchema.optional(),
+  summarizer: ModelSettingsSchema.optional()
+});
+var createApiSchema = (schema) => schema.omit({ tenantId: true, projectId: true });
+var createApiInsertSchema = (schema) => schema.omit({ tenantId: true, projectId: true });
+var createApiUpdateSchema = (schema) => schema.omit({ tenantId: true, projectId: true }).partial();
+var AgentSelectSchema = drizzleZod.createSelectSchema(agents);
+var AgentInsertSchema = drizzleZod.createInsertSchema(agents).extend({
+  id: resourceIdSchema,
+  models: ModelSchema.optional()
+});
+var AgentUpdateSchema = AgentInsertSchema.partial();
+var AgentApiSelectSchema = createApiSchema(AgentSelectSchema);
+var AgentApiInsertSchema = createApiInsertSchema(AgentInsertSchema);
+createApiUpdateSchema(AgentUpdateSchema);
+var AgentRelationSelectSchema = drizzleZod.createSelectSchema(agentRelations);
+var AgentRelationInsertSchema = drizzleZod.createInsertSchema(agentRelations).extend({
+  id: resourceIdSchema,
+  graphId: resourceIdSchema,
+  sourceAgentId: resourceIdSchema,
+  targetAgentId: resourceIdSchema.optional(),
+  externalAgentId: resourceIdSchema.optional()
+});
+var AgentRelationUpdateSchema = AgentRelationInsertSchema.partial();
+createApiSchema(AgentRelationSelectSchema);
+createApiInsertSchema(AgentRelationInsertSchema).extend({
+  relationType: zodOpenapi.z.enum(VALID_RELATION_TYPES)
+}).refine(
+  (data) => {
+    const hasTarget = data.targetAgentId != null;
+    const hasExternal = data.externalAgentId != null;
+    return hasTarget !== hasExternal;
+  },
+  {
+    message: "Must specify exactly one of targetAgentId or externalAgentId",
+    path: ["targetAgentId", "externalAgentId"]
+  }
+);
+createApiUpdateSchema(AgentRelationUpdateSchema).extend({
+  relationType: zodOpenapi.z.enum(VALID_RELATION_TYPES).optional()
+}).refine(
+  (data) => {
+    const hasTarget = data.targetAgentId != null;
+    const hasExternal = data.externalAgentId != null;
+    if (!hasTarget && !hasExternal) {
+      return true;
+    }
+    return hasTarget !== hasExternal;
+  },
+  {
+    message: "Must specify exactly one of targetAgentId or externalAgentId when updating agent relationships",
+    path: ["targetAgentId", "externalAgentId"]
+  }
+);
+zodOpenapi.z.object({
+  sourceAgentId: zodOpenapi.z.string().optional(),
+  targetAgentId: zodOpenapi.z.string().optional(),
+  externalAgentId: zodOpenapi.z.string().optional()
+});
+var ExternalAgentRelationInsertSchema = drizzleZod.createInsertSchema(agentRelations).extend({
+  id: resourceIdSchema,
+  graphId: resourceIdSchema,
+  sourceAgentId: resourceIdSchema,
+  externalAgentId: resourceIdSchema
+});
+createApiInsertSchema(
+  ExternalAgentRelationInsertSchema
+);
+var AgentGraphSelectSchema = drizzleZod.createSelectSchema(agentGraph);
+var AgentGraphInsertSchema = drizzleZod.createInsertSchema(agentGraph).extend({
+  id: resourceIdSchema
+});
+var AgentGraphUpdateSchema = AgentGraphInsertSchema.partial();
+createApiSchema(AgentGraphSelectSchema);
+var AgentGraphApiInsertSchema = createApiInsertSchema(AgentGraphInsertSchema).extend({
+  id: resourceIdSchema.optional()
+});
+createApiUpdateSchema(AgentGraphUpdateSchema);
+var TaskSelectSchema = drizzleZod.createSelectSchema(tasks);
+var TaskInsertSchema = drizzleZod.createInsertSchema(tasks).extend({
+  id: resourceIdSchema,
+  conversationId: resourceIdSchema.optional()
+});
+var TaskUpdateSchema = TaskInsertSchema.partial();
+createApiSchema(TaskSelectSchema);
+createApiInsertSchema(TaskInsertSchema);
+createApiUpdateSchema(TaskUpdateSchema);
+var TaskRelationSelectSchema = drizzleZod.createSelectSchema(taskRelations);
+var TaskRelationInsertSchema = drizzleZod.createInsertSchema(taskRelations).extend({
+  id: resourceIdSchema,
+  parentTaskId: resourceIdSchema,
+  childTaskId: resourceIdSchema
+});
+var TaskRelationUpdateSchema = TaskRelationInsertSchema.partial();
+createApiSchema(TaskRelationSelectSchema);
+createApiInsertSchema(TaskRelationInsertSchema);
+createApiUpdateSchema(TaskRelationUpdateSchema);
+var imageUrlSchema = zodOpenapi.z.string().optional().refine(
+  (url) => {
+    if (!url) return true;
+    if (url.startsWith("data:image/")) {
+      const base64Part = url.split(",")[1];
+      if (!base64Part) return false;
+      return base64Part.length < 14e5;
+    }
+    try {
+      const parsed = new URL(url);
+      return parsed.protocol === "http:" || parsed.protocol === "https:";
+    } catch {
+      return false;
+    }
+  },
+  {
+    message: "Image URL must be a valid HTTP(S) URL or a base64 data URL (max 1MB)"
+  }
+);
+var McpTransportConfigSchema = zodOpenapi.z.object({
+  type: zodOpenapi.z.enum(MCPTransportType),
+  requestInit: zodOpenapi.z.record(zodOpenapi.z.string(), zodOpenapi.z.unknown()).optional(),
+  eventSourceInit: zodOpenapi.z.record(zodOpenapi.z.string(), zodOpenapi.z.unknown()).optional(),
+  reconnectionOptions: zodOpenapi.z.custom().optional(),
+  sessionId: zodOpenapi.z.string().optional()
+});
+var ToolStatusSchema = zodOpenapi.z.enum(TOOL_STATUS_VALUES);
+zodOpenapi.z.object({
+  name: zodOpenapi.z.string(),
+  description: zodOpenapi.z.string().optional(),
+  inputSchema: zodOpenapi.z.record(zodOpenapi.z.string(), zodOpenapi.z.unknown()).optional()
+});
+var ToolSelectSchema = drizzleZod.createSelectSchema(tools);
+var ToolInsertSchema = drizzleZod.createInsertSchema(tools).extend({
+  id: resourceIdSchema,
+  imageUrl: imageUrlSchema
+});
+var ConversationSelectSchema = drizzleZod.createSelectSchema(conversations);
+var ConversationInsertSchema = drizzleZod.createInsertSchema(conversations).extend({
+  id: resourceIdSchema,
+  contextConfigId: resourceIdSchema.optional()
+});
+var ConversationUpdateSchema = ConversationInsertSchema.partial();
+createApiSchema(ConversationSelectSchema);
+createApiInsertSchema(ConversationInsertSchema);
+createApiUpdateSchema(ConversationUpdateSchema);
+var MessageSelectSchema = drizzleZod.createSelectSchema(messages);
+var MessageInsertSchema = drizzleZod.createInsertSchema(messages).extend({
+  id: resourceIdSchema,
+  conversationId: resourceIdSchema,
+  taskId: resourceIdSchema.optional()
+});
+var MessageUpdateSchema = MessageInsertSchema.partial();
+createApiSchema(MessageSelectSchema);
+createApiInsertSchema(MessageInsertSchema);
+createApiUpdateSchema(MessageUpdateSchema);
+var ContextCacheSelectSchema = drizzleZod.createSelectSchema(contextCache);
+var ContextCacheInsertSchema = drizzleZod.createInsertSchema(contextCache);
+var ContextCacheUpdateSchema = ContextCacheInsertSchema.partial();
+createApiSchema(ContextCacheSelectSchema);
+createApiInsertSchema(ContextCacheInsertSchema);
+createApiUpdateSchema(ContextCacheUpdateSchema);
+var DataComponentSelectSchema = drizzleZod.createSelectSchema(dataComponents);
+var DataComponentInsertSchema = drizzleZod.createInsertSchema(dataComponents).extend({
+  id: resourceIdSchema
+});
+DataComponentInsertSchema.omit({
+  createdAt: true,
+  updatedAt: true
+});
+var DataComponentUpdateSchema = DataComponentInsertSchema.partial();
+createApiSchema(DataComponentSelectSchema);
+var DataComponentApiInsertSchema = createApiInsertSchema(DataComponentInsertSchema);
+createApiUpdateSchema(DataComponentUpdateSchema);
+var AgentDataComponentSelectSchema = drizzleZod.createSelectSchema(agentDataComponents);
+var AgentDataComponentInsertSchema = drizzleZod.createInsertSchema(agentDataComponents);
+var AgentDataComponentUpdateSchema = AgentDataComponentInsertSchema.partial();
+createApiSchema(AgentDataComponentSelectSchema);
+createApiInsertSchema(
+  AgentDataComponentInsertSchema
+);
+createApiUpdateSchema(
+  AgentDataComponentUpdateSchema
+);
+var ArtifactComponentSelectSchema = drizzleZod.createSelectSchema(artifactComponents);
+var ArtifactComponentInsertSchema = drizzleZod.createInsertSchema(artifactComponents).extend({
+  id: resourceIdSchema
+});
+var ArtifactComponentUpdateSchema = ArtifactComponentInsertSchema.partial();
+createApiSchema(ArtifactComponentSelectSchema);
+var ArtifactComponentApiInsertSchema = ArtifactComponentInsertSchema.omit({
+  tenantId: true,
+  projectId: true,
+  createdAt: true,
+  updatedAt: true
+}).extend({
+  id: resourceIdSchema.optional()
+});
+createApiUpdateSchema(
+  ArtifactComponentUpdateSchema
+);
+var AgentArtifactComponentSelectSchema = drizzleZod.createSelectSchema(agentArtifactComponents);
+var AgentArtifactComponentInsertSchema = drizzleZod.createInsertSchema(
+  agentArtifactComponents
+).extend({
+  id: resourceIdSchema,
+  agentId: resourceIdSchema,
+  artifactComponentId: resourceIdSchema
+});
+var AgentArtifactComponentUpdateSchema = AgentArtifactComponentInsertSchema.partial();
+createApiSchema(
+  AgentArtifactComponentSelectSchema
+);
+AgentArtifactComponentInsertSchema.omit({
+  tenantId: true,
+  projectId: true,
+  id: true,
+  createdAt: true
+});
+createApiUpdateSchema(
+  AgentArtifactComponentUpdateSchema
+);
+var ExternalAgentSelectSchema = drizzleZod.createSelectSchema(externalAgents).extend({
+  credentialReferenceId: zodOpenapi.z.string().nullable().optional(),
+  headers: zodOpenapi.z.record(zodOpenapi.z.string(), zodOpenapi.z.string()).nullable().optional()
+});
+var ExternalAgentInsertSchema = drizzleZod.createInsertSchema(externalAgents).extend({
+  id: resourceIdSchema
+});
+var ExternalAgentUpdateSchema = ExternalAgentInsertSchema.partial();
+var ExternalAgentApiSelectSchema = createApiSchema(ExternalAgentSelectSchema);
+var ExternalAgentApiInsertSchema = createApiInsertSchema(ExternalAgentInsertSchema);
+createApiUpdateSchema(ExternalAgentUpdateSchema);
+zodOpenapi.z.discriminatedUnion("type", [
+  AgentApiSelectSchema.extend({ type: zodOpenapi.z.literal("internal") }),
+  ExternalAgentApiSelectSchema.extend({ type: zodOpenapi.z.literal("external") })
+]);
+var ApiKeySelectSchema = drizzleZod.createSelectSchema(apiKeys);
+var ApiKeyInsertSchema = drizzleZod.createInsertSchema(apiKeys).extend({
+  id: resourceIdSchema,
+  graphId: resourceIdSchema
+});
+ApiKeyInsertSchema.partial().omit({
+  tenantId: true,
+  projectId: true,
+  id: true,
+  publicId: true,
+  keyHash: true,
+  keyPrefix: true,
+  createdAt: true
+});
+var ApiKeyApiSelectSchema = ApiKeySelectSchema.omit({
+  tenantId: true,
+  projectId: true,
+  keyHash: true
+  // Never expose the hash
+});
+zodOpenapi.z.object({
+  data: zodOpenapi.z.object({
+    apiKey: ApiKeyApiSelectSchema,
+    key: zodOpenapi.z.string().describe("The full API key (shown only once)")
+  })
+});
+ApiKeyInsertSchema.omit({
+  tenantId: true,
+  projectId: true,
+  id: true,
+  // Auto-generated
+  publicId: true,
+  // Auto-generated
+  keyHash: true,
+  // Auto-generated
+  keyPrefix: true,
+  // Auto-generated
+  lastUsedAt: true
+  // Not set on creation
+});
+var CredentialReferenceSelectSchema = zodOpenapi.z.object({
+  id: zodOpenapi.z.string(),
+  tenantId: zodOpenapi.z.string(),
+  projectId: zodOpenapi.z.string(),
+  type: zodOpenapi.z.string(),
+  credentialStoreId: zodOpenapi.z.string(),
+  retrievalParams: zodOpenapi.z.record(zodOpenapi.z.string(), zodOpenapi.z.unknown()).nullish(),
+  createdAt: zodOpenapi.z.string(),
+  updatedAt: zodOpenapi.z.string()
+});
+var CredentialReferenceInsertSchema = zodOpenapi.z.object({
+  id: resourceIdSchema,
+  tenantId: zodOpenapi.z.string(),
+  projectId: zodOpenapi.z.string(),
+  type: zodOpenapi.z.string(),
+  credentialStoreId: resourceIdSchema,
+  retrievalParams: zodOpenapi.z.record(zodOpenapi.z.string(), zodOpenapi.z.unknown()).nullish()
+});
+var CredentialReferenceUpdateSchema = CredentialReferenceInsertSchema.partial();
+createApiSchema(
+  CredentialReferenceSelectSchema
+).extend({
+  type: zodOpenapi.z.enum(CredentialStoreType)
+});
+var CredentialReferenceApiInsertSchema = createApiInsertSchema(
+  CredentialReferenceInsertSchema
+).extend({
+  type: zodOpenapi.z.enum(CredentialStoreType)
+});
+createApiUpdateSchema(
+  CredentialReferenceUpdateSchema
+).extend({
+  type: zodOpenapi.z.enum(CredentialStoreType).optional()
+});
+var McpToolSchema = ToolInsertSchema.extend({
+  imageUrl: imageUrlSchema,
+  status: ToolStatusSchema.default("unknown"),
+  lastHealthCheck: zodOpenapi.z.date().optional(),
+  lastToolsSync: zodOpenapi.z.date().optional(),
+  version: zodOpenapi.z.string().optional(),
+  createdAt: zodOpenapi.z.date(),
+  updatedAt: zodOpenapi.z.date()
+});
+McpToolSchema.omit({
+  config: true,
+  tenantId: true,
+  projectId: true,
+  status: true,
+  lastHealthCheck: true,
+  lastToolsSync: true,
+  version: true,
+  createdAt: true,
+  updatedAt: true,
+  credentialReferenceId: true
+}).extend({
+  tenantId: zodOpenapi.z.string().optional(),
+  projectId: zodOpenapi.z.string().optional(),
+  description: zodOpenapi.z.string().optional(),
+  serverUrl: zodOpenapi.z.url(),
+  activeTools: zodOpenapi.z.array(zodOpenapi.z.string()).optional(),
+  mcpType: zodOpenapi.z.enum(MCPServerType).optional(),
+  transport: McpTransportConfigSchema.optional(),
+  credential: CredentialReferenceApiInsertSchema.optional()
+});
+var ToolUpdateSchema = ToolInsertSchema.partial();
+createApiSchema(ToolSelectSchema);
+var ToolApiInsertSchema = createApiInsertSchema(ToolInsertSchema);
+createApiUpdateSchema(ToolUpdateSchema);
+var FetchConfigSchema = zodOpenapi.z.object({
+  url: zodOpenapi.z.string().min(1, "URL is required"),
+  method: zodOpenapi.z.enum(["GET", "POST", "PUT", "DELETE", "PATCH"]).optional().default("GET"),
+  headers: zodOpenapi.z.record(zodOpenapi.z.string(), zodOpenapi.z.string()).optional(),
+  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()
+});
+zodOpenapi.z.object({
+  id: zodOpenapi.z.string().min(1, "Fetch definition ID is required"),
+  name: zodOpenapi.z.string().optional(),
+  trigger: zodOpenapi.z.enum(["initialization", "invocation"]),
+  fetchConfig: FetchConfigSchema,
+  responseSchema: zodOpenapi.z.any().optional(),
+  // JSON Schema for validating HTTP response
+  defaultValue: zodOpenapi.z.unknown().optional(),
+  credential: CredentialReferenceApiInsertSchema.optional()
+});
+var ContextConfigSelectSchema = drizzleZod.createSelectSchema(contextConfigs).extend({
+  requestContextSchema: zodOpenapi.z.unknown().optional()
+});
+var ContextConfigInsertSchema = drizzleZod.createInsertSchema(contextConfigs).extend({
+  id: resourceIdSchema,
+  requestContextSchema: zodOpenapi.z.unknown().optional()
+}).omit({
+  createdAt: true,
+  updatedAt: true
+});
+var ContextConfigUpdateSchema = ContextConfigInsertSchema.partial();
+createApiSchema(ContextConfigSelectSchema);
+var ContextConfigApiInsertSchema = createApiInsertSchema(ContextConfigInsertSchema);
+createApiUpdateSchema(ContextConfigUpdateSchema);
+var AgentToolRelationSelectSchema = drizzleZod.createSelectSchema(agentToolRelations);
+var AgentToolRelationInsertSchema = drizzleZod.createInsertSchema(agentToolRelations).extend({
+  id: resourceIdSchema,
+  agentId: resourceIdSchema,
+  toolId: resourceIdSchema,
+  selectedTools: zodOpenapi.z.array(zodOpenapi.z.string()).nullish()
+});
+var AgentToolRelationUpdateSchema = AgentToolRelationInsertSchema.partial();
+createApiSchema(AgentToolRelationSelectSchema);
+createApiInsertSchema(
+  AgentToolRelationInsertSchema
+);
+createApiUpdateSchema(
+  AgentToolRelationUpdateSchema
+);
+var LedgerArtifactSelectSchema = drizzleZod.createSelectSchema(ledgerArtifacts);
+var LedgerArtifactInsertSchema = drizzleZod.createInsertSchema(ledgerArtifacts);
+var LedgerArtifactUpdateSchema = LedgerArtifactInsertSchema.partial();
+createApiSchema(LedgerArtifactSelectSchema);
+createApiInsertSchema(LedgerArtifactInsertSchema);
+createApiUpdateSchema(LedgerArtifactUpdateSchema);
+var StatusComponentSchema = zodOpenapi.z.object({
+  type: zodOpenapi.z.string(),
+  description: zodOpenapi.z.string().optional(),
+  detailsSchema: zodOpenapi.z.object({
+    type: zodOpenapi.z.literal("object"),
+    properties: zodOpenapi.z.record(zodOpenapi.z.string(), zodOpenapi.z.any()),
+    required: zodOpenapi.z.array(zodOpenapi.z.string()).optional()
+  }).optional()
+});
+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(),
+  statusComponents: zodOpenapi.z.array(StatusComponentSchema).optional()
+});
+var FullGraphAgentInsertSchema = AgentApiInsertSchema.extend({
+  tools: zodOpenapi.z.array(zodOpenapi.z.string()),
+  selectedTools: zodOpenapi.z.record(zodOpenapi.z.string(), zodOpenapi.z.array(zodOpenapi.z.string())).optional(),
+  dataComponents: zodOpenapi.z.array(zodOpenapi.z.string()).optional(),
+  artifactComponents: zodOpenapi.z.array(zodOpenapi.z.string()).optional(),
+  canTransferTo: zodOpenapi.z.array(zodOpenapi.z.string()).optional(),
+  canDelegateTo: zodOpenapi.z.array(zodOpenapi.z.string()).optional()
+});
+AgentGraphApiInsertSchema.extend({
+  agents: zodOpenapi.z.record(zodOpenapi.z.string(), zodOpenapi.z.union([FullGraphAgentInsertSchema, ExternalAgentApiInsertSchema])),
+  tools: zodOpenapi.z.record(zodOpenapi.z.string(), ToolApiInsertSchema).optional(),
+  credentialReferences: zodOpenapi.z.array(CredentialReferenceApiInsertSchema).optional(),
+  dataComponents: zodOpenapi.z.record(zodOpenapi.z.string(), DataComponentApiInsertSchema).optional(),
+  artifactComponents: zodOpenapi.z.record(zodOpenapi.z.string(), ArtifactComponentApiInsertSchema).optional(),
+  contextConfig: zodOpenapi.z.optional(ContextConfigApiInsertSchema),
+  statusUpdates: zodOpenapi.z.optional(StatusUpdateSchema),
+  models: ModelSchema.optional(),
+  stopWhen: GraphStopWhenSchema.optional(),
+  graphPrompt: zodOpenapi.z.string().max(5e3, "Graph prompt cannot exceed 5000 characters").optional()
+});
+var GraphWithinContextOfProjectSchema = AgentGraphApiInsertSchema.extend({
+  agents: zodOpenapi.z.record(zodOpenapi.z.string(), zodOpenapi.z.union([FullGraphAgentInsertSchema, ExternalAgentApiInsertSchema])),
+  models: ModelSchema.optional(),
+  stopWhen: GraphStopWhenSchema.optional(),
+  graphPrompt: zodOpenapi.z.string().max(5e3, "Graph prompt cannot exceed 5000 characters").optional()
+});
+zodOpenapi.z.object({
+  page: zodOpenapi.z.coerce.number().min(1).default(1),
+  limit: zodOpenapi.z.coerce.number().min(1).max(100).default(10),
+  total: zodOpenapi.z.number(),
+  pages: zodOpenapi.z.number()
+});
+zodOpenapi.z.object({
+  error: zodOpenapi.z.string(),
+  message: zodOpenapi.z.string().optional(),
+  details: zodOpenapi.z.unknown().optional()
+});
+zodOpenapi.z.object({
+  exists: zodOpenapi.z.boolean()
+});
+zodOpenapi.z.object({
+  message: zodOpenapi.z.string(),
+  removed: zodOpenapi.z.boolean()
+});
+var ProjectSelectSchema = drizzleZod.createSelectSchema(projects);
+var ProjectInsertSchema = drizzleZod.createInsertSchema(projects).extend({
+  models: ProjectModelSchema.optional(),
+  stopWhen: StopWhenSchema.optional()
+}).omit({
+  createdAt: true,
+  updatedAt: true
+});
+var ProjectUpdateSchema = ProjectInsertSchema.partial();
+ProjectSelectSchema.omit({ tenantId: true });
+var ProjectApiInsertSchema = ProjectInsertSchema.omit({ tenantId: true });
+ProjectUpdateSchema.omit({ tenantId: true });
+ProjectApiInsertSchema.extend({
+  graphs: zodOpenapi.z.record(zodOpenapi.z.string(), GraphWithinContextOfProjectSchema),
+  tools: zodOpenapi.z.record(zodOpenapi.z.string(), ToolApiInsertSchema),
+  dataComponents: zodOpenapi.z.record(zodOpenapi.z.string(), DataComponentApiInsertSchema).optional(),
+  artifactComponents: zodOpenapi.z.record(zodOpenapi.z.string(), ArtifactComponentApiInsertSchema).optional(),
+  contextConfig: zodOpenapi.z.record(zodOpenapi.z.string(), ContextConfigApiInsertSchema).optional(),
+  statusUpdates: zodOpenapi.z.optional(StatusUpdateSchema),
+  credentialReferences: zodOpenapi.z.array(CredentialReferenceApiInsertSchema).optional(),
+  createdAt: zodOpenapi.z.string().optional(),
+  updatedAt: zodOpenapi.z.string().optional()
+});
+zodOpenapi.z.object({
+  "x-inkeep-tenant-id": zodOpenapi.z.string().optional().openapi({
+    description: "Tenant identifier",
+    example: "tenant_123"
+  }),
+  "x-inkeep-project-id": zodOpenapi.z.string().optional().openapi({
+    description: "Project identifier",
+    example: "project_456"
+  }),
+  "x-inkeep-graph-id": zodOpenapi.z.string().optional().openapi({
+    description: "Graph identifier",
+    example: "graph_789"
+  })
+});
+zodOpenapi.z.object({
+  tenantId: zodOpenapi.z.string().openapi({
+    description: "Tenant identifier",
+    example: "tenant_123"
+  })
+}).openapi("TenantParams");
+zodOpenapi.z.object({
+  tenantId: zodOpenapi.z.string().openapi({
+    description: "Tenant identifier",
+    example: "tenant_123"
+  }),
+  projectId: zodOpenapi.z.string().openapi({
+    description: "Project identifier",
+    example: "project_456"
+  })
+}).openapi("TenantProjectParams");
+zodOpenapi.z.object({
+  tenantId: zodOpenapi.z.string().openapi({
+    description: "Tenant identifier",
+    example: "tenant_123"
+  }),
+  projectId: zodOpenapi.z.string().openapi({
+    description: "Project identifier",
+    example: "project_456"
+  }),
+  id: resourceIdSchema
+}).openapi("TenantProjectIdParams");
+zodOpenapi.z.object({
+  tenantId: zodOpenapi.z.string().openapi({
+    description: "Tenant identifier",
+    example: "tenant_123"
+  }),
+  id: resourceIdSchema
+}).openapi("TenantIdParams");
+zodOpenapi.z.object({
+  id: resourceIdSchema
+}).openapi("IdParams");
+zodOpenapi.z.object({
+  page: zodOpenapi.z.coerce.number().min(1).default(1),
+  limit: zodOpenapi.z.coerce.number().min(1).max(100).default(10)
+});
+
+// src/client-exports.ts
+var TenantParamsSchema2 = zod.z.object({
+  tenantId: zod.z.string()
+});
+var TenantProjectParamsSchema2 = TenantParamsSchema2.extend({
+  projectId: zod.z.string()
+});
+var TenantProjectIdParamsSchema2 = TenantProjectParamsSchema2.extend({
+  id: zod.z.string()
+});
+var IdParamsSchema2 = zod.z.object({
+  id: zod.z.string()
+});
+var PaginationSchema2 = zod.z.object({
+  page: zod.z.coerce.number().min(1).default(1),
+  limit: zod.z.coerce.number().min(1).max(100).default(10),
+  total: zod.z.number(),
+  pages: zod.z.number()
+});
+var ListResponseSchema = (itemSchema) => zod.z.object({
+  data: zod.z.array(itemSchema),
+  pagination: PaginationSchema2
+});
+var SingleResponseSchema = (itemSchema) => zod.z.object({
+  data: itemSchema
+});
+var ErrorResponseSchema2 = zod.z.object({
+  error: zod.z.string(),
+  message: zod.z.string().optional(),
+  details: zod.z.unknown().optional()
+});
+var ModelSettingsSchema2 = zod.z.object({
+  model: zod.z.string().optional(),
+  structuredOutput: zod.z.string().optional(),
+  summarizer: zod.z.string().optional(),
+  providerOptions: zod.z.record(zod.z.string(), zod.z.record(zod.z.string(), zod.z.unknown())).optional()
+});
+var AgentApiInsertSchema2 = zod.z.object({
+  id: zod.z.string().optional(),
+  name: zod.z.string(),
+  description: zod.z.string().optional(),
+  prompt: zod.z.string().optional(),
+  model: ModelSettingsSchema2.optional(),
+  tools: zod.z.array(zod.z.string()).optional(),
+  dataComponents: zod.z.array(zod.z.string()).optional(),
+  artifactComponents: zod.z.array(zod.z.string()).optional(),
+  canTransferTo: zod.z.array(zod.z.string()).optional(),
+  canDelegateTo: zod.z.array(zod.z.string()).optional(),
+  type: zod.z.enum(["internal", "external"]).optional()
+});
+var ToolApiInsertSchema2 = zod.z.object({
+  id: zod.z.string().optional(),
+  name: zod.z.string(),
+  description: zod.z.string().optional(),
+  type: zod.z.enum(["mcp", "hosted"]),
+  config: zod.z.record(zod.z.string(), zod.z.unknown()),
+  credentialReferenceId: zod.z.string().optional()
+});
+var ApiKeyApiSelectSchema2 = zod.z.object({
+  id: zod.z.string(),
+  tenantId: zod.z.string(),
+  projectId: zod.z.string(),
+  graphId: zod.z.string(),
+  publicId: zod.z.string(),
+  keyHash: zod.z.string(),
+  keyPrefix: zod.z.string(),
+  name: zod.z.string().optional(),
+  lastUsedAt: zod.z.string().optional(),
+  expiresAt: zod.z.string().optional(),
+  createdAt: zod.z.string(),
+  updatedAt: zod.z.string()
+});
+var ApiKeyApiCreationResponseSchema2 = zod.z.object({
+  data: zod.z.object({
+    apiKey: ApiKeyApiSelectSchema2,
+    key: zod.z.string()
+  })
+});
+var CredentialReferenceApiInsertSchema2 = zod.z.object({
+  id: zod.z.string(),
+  tenantId: zod.z.string().optional(),
+  projectId: zod.z.string().optional(),
+  type: zod.z.enum(CredentialStoreType),
+  credentialStoreId: zod.z.string(),
+  retrievalParams: zod.z.record(zod.z.string(), zod.z.unknown()).nullish()
+});
+var DataComponentApiInsertSchema2 = zod.z.object({
+  id: zod.z.string().optional(),
+  name: zod.z.string(),
+  description: zod.z.string().optional(),
+  props: zod.z.record(zod.z.string(), zod.z.unknown())
+});
+var ArtifactComponentApiInsertSchema2 = zod.z.object({
+  id: zod.z.string().optional(),
+  name: zod.z.string(),
+  description: zod.z.string().optional(),
+  summaryProps: zod.z.record(zod.z.string(), zod.z.unknown()),
+  fullProps: zod.z.record(zod.z.string(), zod.z.unknown())
+});
+var ContextConfigApiInsertSchema2 = zod.z.object({
+  id: zod.z.string().optional(),
+  name: zod.z.string().optional(),
+  description: zod.z.string().optional(),
+  type: zod.z.string().optional(),
+  config: zod.z.record(zod.z.string(), zod.z.unknown()).optional()
+});
+var ExternalAgentApiInsertSchema2 = zod.z.object({
+  id: zod.z.string().optional(),
+  name: zod.z.string(),
+  description: zod.z.string().optional(),
+  baseUrl: zod.z.string(),
+  type: zod.z.literal("external").optional()
+});
+var AgentGraphApiInsertSchema2 = zod.z.object({
+  id: zod.z.string().optional(),
+  name: zod.z.string(),
+  description: zod.z.string().optional(),
+  defaultAgentId: zod.z.string().optional()
+});
+var FullGraphDefinitionSchema2 = AgentGraphApiInsertSchema2.extend({
+  agents: zod.z.record(
+    zod.z.string(),
+    zod.z.union([
+      AgentApiInsertSchema2.extend({
+        id: zod.z.string(),
+        tools: zod.z.array(zod.z.string()),
+        dataComponents: zod.z.array(zod.z.string()).optional(),
+        artifactComponents: zod.z.array(zod.z.string()).optional(),
+        canTransferTo: zod.z.array(zod.z.string()).optional(),
+        canDelegateTo: zod.z.array(zod.z.string()).optional(),
+        type: zod.z.enum(["internal", "external"]).optional(),
+        models: zod.z.object({
+          base: zod.z.object({
+            model: zod.z.string(),
+            providerOptions: zod.z.record(zod.z.string(), zod.z.record(zod.z.string(), zod.z.unknown())).optional()
+          }).optional(),
+          structuredOutput: zod.z.object({
+            model: zod.z.string(),
+            providerOptions: zod.z.record(zod.z.string(), zod.z.record(zod.z.string(), zod.z.unknown())).optional()
+          }).optional(),
+          summarizer: zod.z.object({
+            model: zod.z.string(),
+            providerOptions: zod.z.record(zod.z.string(), zod.z.record(zod.z.string(), zod.z.unknown())).optional()
+          }).optional()
+        }).optional()
+      }),
+      ExternalAgentApiInsertSchema2.extend({
+        id: zod.z.string()
+      })
+    ])
+  ),
+  tools: zod.z.record(zod.z.string(), ToolApiInsertSchema2),
+  credentialReferences: zod.z.array(CredentialReferenceApiInsertSchema2).optional(),
+  dataComponents: zod.z.record(zod.z.string(), DataComponentApiInsertSchema2).optional(),
+  artifactComponents: zod.z.record(zod.z.string(), ArtifactComponentApiInsertSchema2).optional(),
+  contextConfig: zod.z.optional(ContextConfigApiInsertSchema2),
+  models: zod.z.object({
+    base: zod.z.object({
+      model: zod.z.string(),
+      providerOptions: zod.z.record(zod.z.string(), zod.z.record(zod.z.string(), zod.z.unknown())).optional()
+    }).optional(),
+    structuredOutput: zod.z.object({
+      model: zod.z.string(),
+      providerOptions: zod.z.record(zod.z.string(), zod.z.record(zod.z.string(), zod.z.unknown())).optional()
+    }).optional(),
+    summarizer: zod.z.object({
+      model: zod.z.string(),
+      providerOptions: zod.z.record(zod.z.string(), zod.z.record(zod.z.string(), zod.z.unknown())).optional()
+    }).optional()
+  }).optional(),
+  stopWhen: zod.z.object({
+    transferCountIs: zod.z.number().min(1).max(100).optional()
+  }).optional(),
+  graphPrompt: zod.z.string().max(5e3).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(),
+    statusComponents: zod.z.array(
+      zod.z.object({
+        type: zod.z.string(),
+        description: zod.z.string().optional(),
+        detailsSchema: zod.z.object({
+          type: zod.z.literal("object"),
+          properties: zod.z.record(zod.z.string(), zod.z.any()),
+          required: zod.z.array(zod.z.string()).optional()
+        }).optional()
+      })
+    ).optional()
+  }).optional()
+});
+var MIN_ID_LENGTH2 = 1;
+var MAX_ID_LENGTH2 = 255;
+var URL_SAFE_ID_PATTERN2 = /^[a-zA-Z0-9\-_.]+$/;
+var resourceIdSchema2 = zod.z.string().min(MIN_ID_LENGTH2).max(MAX_ID_LENGTH2).regex(URL_SAFE_ID_PATTERN2, {
+  message: "ID must contain only letters, numbers, hyphens, underscores, and dots"
+});
+function generateIdFromName(name) {
+  return name.toLowerCase().replace(/[^a-zA-Z0-9]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "").slice(0, MAX_ID_LENGTH2);
+}
+
+exports.AgentApiInsertSchema = AgentApiInsertSchema2;
+exports.AgentGraphApiInsertSchema = AgentGraphApiInsertSchema2;
+exports.AgentStopWhenSchema = AgentStopWhenSchema;
+exports.ApiKeyApiCreationResponseSchema = ApiKeyApiCreationResponseSchema2;
+exports.ApiKeyApiSelectSchema = ApiKeyApiSelectSchema2;
+exports.ArtifactComponentApiInsertSchema = ArtifactComponentApiInsertSchema2;
+exports.ContextConfigApiInsertSchema = ContextConfigApiInsertSchema2;
+exports.CredentialReferenceApiInsertSchema = CredentialReferenceApiInsertSchema2;
+exports.CredentialStoreType = CredentialStoreType;
+exports.DataComponentApiInsertSchema = DataComponentApiInsertSchema2;
+exports.ErrorResponseSchema = ErrorResponseSchema2;
+exports.ExternalAgentApiInsertSchema = ExternalAgentApiInsertSchema2;
+exports.FullGraphDefinitionSchema = FullGraphDefinitionSchema2;
+exports.GraphStopWhenSchema = GraphStopWhenSchema;
+exports.IdParamsSchema = IdParamsSchema2;
+exports.ListResponseSchema = ListResponseSchema;
+exports.MAX_ID_LENGTH = MAX_ID_LENGTH2;
+exports.MCPTransportType = MCPTransportType;
+exports.MIN_ID_LENGTH = MIN_ID_LENGTH2;
+exports.ModelSettingsSchema = ModelSettingsSchema2;
+exports.PaginationSchema = PaginationSchema2;
+exports.SingleResponseSchema = SingleResponseSchema;
+exports.StopWhenSchema = StopWhenSchema;
+exports.TenantParamsSchema = TenantParamsSchema2;
+exports.TenantProjectIdParamsSchema = TenantProjectIdParamsSchema2;
+exports.TenantProjectParamsSchema = TenantProjectParamsSchema2;
+exports.ToolApiInsertSchema = ToolApiInsertSchema2;
+exports.URL_SAFE_ID_PATTERN = URL_SAFE_ID_PATTERN2;
+exports.generateIdFromName = generateIdFromName;
+exports.resourceIdSchema = resourceIdSchema2;