@inkeep/agents-core 0.18.1 → 0.19.1

package/dist/validation/index.cjs

@@ -57,12 +57,12 @@ var projectScoped = {
   ...tenantScoped,
   projectId: sqliteCore.text("project_id").notNull()
 };
-var graphScoped = {
+var agentScoped = {
   ...projectScoped,
-  graphId: sqliteCore.text("graph_id").notNull()
+  agentId: sqliteCore.text("agent_id").notNull()
 };
 var subAgentScoped = {
-  ...graphScoped,
+  ...agentScoped,
   subAgentId: sqliteCore.text("sub_agent_id").notNull()
 };
 var uiProperties = {
@@ -78,9 +78,9 @@ var projects = sqliteCore.sqliteTable(
   {
     ...tenantScoped,
     ...uiProperties,
-    // Project-level default model settings that can be inherited by graphs and agents
+    // Project-level default model settings that can be inherited by agents
     models: sqliteCore.text("models", { mode: "json" }).$type(),
-    // Project-level stopWhen configuration that can be inherited by graphs and agents
+    // Project-level stopWhen configuration that can be inherited by agents
     stopWhen: sqliteCore.text("stop_when", { mode: "json" }).$type(),
     // Project-level sandbox configuration for function execution
     sandboxConfig: sqliteCore.text("sandbox_config", { mode: "json" }).$type(),
@@ -88,23 +88,17 @@ var projects = sqliteCore.sqliteTable(
   },
   (table) => [sqliteCore.primaryKey({ columns: [table.tenantId, table.id] })]
 );
-var agentGraph = sqliteCore.sqliteTable(
-  "agent_graph",
+var agents = sqliteCore.sqliteTable(
+  "agent",
   {
     ...projectScoped,
     name: sqliteCore.text("name").notNull(),
     description: sqliteCore.text("description"),
     defaultSubAgentId: sqliteCore.text("default_sub_agent_id"),
-    // Reference to shared context configuration for all agents in this graph
     contextConfigId: sqliteCore.text("context_config_id"),
-    // add fk relationship
-    // 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
+    prompt: sqliteCore.text("prompt"),
     stopWhen: sqliteCore.text("stop_when", { mode: "json" }).$type(),
     ...timestamps
   },
@@ -113,27 +107,26 @@ var agentGraph = sqliteCore.sqliteTable(
     sqliteCore.foreignKey({
       columns: [table.tenantId, table.projectId],
       foreignColumns: [projects.tenantId, projects.id],
-      name: "agent_graph_project_fk"
+      name: "agent_project_fk"
     }).onDelete("cascade")
   ]
 );
 var contextConfigs = sqliteCore.sqliteTable(
   "context_configs",
   {
-    ...graphScoped,
+    ...agentScoped,
     // Developer-defined Zod schema for validating incoming request context
     headersSchema: sqliteCore.blob("headers_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(),
     ...timestamps
   },
   (table) => [
-    sqliteCore.primaryKey({ columns: [table.tenantId, table.projectId, table.graphId, table.id] }),
+    sqliteCore.primaryKey({ columns: [table.tenantId, table.projectId, table.agentId, table.id] }),
     sqliteCore.foreignKey({
-      columns: [table.tenantId, table.projectId, table.graphId],
-      foreignColumns: [agentGraph.tenantId, agentGraph.projectId, agentGraph.id],
-      name: "context_configs_graph_fk"
+      columns: [table.tenantId, table.projectId, table.agentId],
+      foreignColumns: [agents.tenantId, agents.projectId, agents.id],
+      name: "context_configs_agent_fk"
     }).onDelete("cascade")
   ]
 );
@@ -146,16 +139,12 @@ var contextCache = sqliteCore.sqliteTable(
     // 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"),
     ...timestamps
   },
@@ -176,30 +165,29 @@ var contextCache = sqliteCore.sqliteTable(
 var subAgents = sqliteCore.sqliteTable(
   "sub_agents",
   {
-    ...graphScoped,
+    ...agentScoped,
     ...uiProperties,
     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(),
     ...timestamps
   },
   (table) => [
-    sqliteCore.primaryKey({ columns: [table.tenantId, table.projectId, table.graphId, table.id] }),
+    sqliteCore.primaryKey({ columns: [table.tenantId, table.projectId, table.agentId, table.id] }),
     sqliteCore.foreignKey({
-      columns: [table.tenantId, table.projectId, table.graphId],
-      foreignColumns: [agentGraph.tenantId, agentGraph.projectId, agentGraph.id],
-      name: "agents_graph_fk"
+      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(
   "sub_agent_relations",
   {
-    ...graphScoped,
+    ...agentScoped,
     sourceSubAgentId: sqliteCore.text("source_sub_agent_id").notNull(),
     // For internal relationships
     targetSubAgentId: sqliteCore.text("target_sub_agent_id"),
@@ -209,31 +197,30 @@ var subAgentRelations = sqliteCore.sqliteTable(
     ...timestamps
   },
   (table) => [
-    sqliteCore.primaryKey({ columns: [table.tenantId, table.projectId, table.graphId, table.id] }),
+    sqliteCore.primaryKey({ columns: [table.tenantId, table.projectId, table.agentId, table.id] }),
     sqliteCore.foreignKey({
-      columns: [table.tenantId, table.projectId, table.graphId],
-      foreignColumns: [agentGraph.tenantId, agentGraph.projectId, agentGraph.id],
-      name: "sub_agent_relations_graph_fk"
+      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(
   "external_agents",
   {
-    ...graphScoped,
+    ...agentScoped,
     ...uiProperties,
     baseUrl: sqliteCore.text("base_url").notNull(),
-    // A2A endpoint URL
     credentialReferenceId: sqliteCore.text("credential_reference_id"),
     headers: sqliteCore.blob("headers", { mode: "json" }).$type(),
     ...timestamps
   },
   (table) => [
-    sqliteCore.primaryKey({ columns: [table.tenantId, table.projectId, table.graphId, table.id] }),
+    sqliteCore.primaryKey({ columns: [table.tenantId, table.projectId, table.agentId, table.id] }),
     sqliteCore.foreignKey({
-      columns: [table.tenantId, table.projectId, table.graphId],
-      foreignColumns: [agentGraph.tenantId, agentGraph.projectId, agentGraph.id],
-      name: "external_agents_graph_fk"
+      columns: [table.tenantId, table.projectId, table.agentId],
+      foreignColumns: [agents.tenantId, agents.projectId, agents.id],
+      name: "external_agents_agent_fk"
     }).onDelete("cascade"),
     sqliteCore.foreignKey({
       columns: [table.tenantId, table.projectId, table.credentialReferenceId],
@@ -258,8 +245,8 @@ var tasks = sqliteCore.sqliteTable(
   (table) => [
     sqliteCore.primaryKey({ columns: [table.tenantId, table.projectId, table.id] }),
     sqliteCore.foreignKey({
-      columns: [table.tenantId, table.projectId, table.graphId, table.subAgentId],
-      foreignColumns: [subAgents.tenantId, subAgents.projectId, subAgents.graphId, subAgents.id],
+      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")
   ]
@@ -271,7 +258,6 @@ var taskRelations = sqliteCore.sqliteTable(
     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
     ...timestamps
   },
   (table) => [
@@ -309,13 +295,11 @@ var subAgentDataComponents = sqliteCore.sqliteTable(
   },
   (table) => [
     sqliteCore.primaryKey({ columns: [table.tenantId, table.projectId, table.id] }),
-    // Foreign key constraint to agents table (ensures graph and project exist via cascade)
     sqliteCore.foreignKey({
-      columns: [table.tenantId, table.projectId, table.graphId, table.subAgentId],
-      foreignColumns: [subAgents.tenantId, subAgents.projectId, subAgents.graphId, subAgents.id],
+      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"),
-    // Foreign key constraint to data_components table
     sqliteCore.foreignKey({
       columns: [table.tenantId, table.projectId, table.dataComponentId],
       foreignColumns: [dataComponents.tenantId, dataComponents.projectId, dataComponents.id],
@@ -349,15 +333,13 @@ var subAgentArtifactComponents = sqliteCore.sqliteTable(
   },
   (table) => [
     sqliteCore.primaryKey({
-      columns: [table.tenantId, table.projectId, table.graphId, table.subAgentId, table.id]
+      columns: [table.tenantId, table.projectId, table.agentId, table.subAgentId, table.id]
     }),
-    // Foreign key constraint to agents table (ensures graph and project exist via cascade)
     sqliteCore.foreignKey({
-      columns: [table.tenantId, table.projectId, table.graphId, table.subAgentId],
-      foreignColumns: [subAgents.tenantId, subAgents.projectId, subAgents.graphId, subAgents.id],
+      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"),
-    // Foreign key constraint to artifact_components table
     sqliteCore.foreignKey({
       columns: [table.tenantId, table.projectId, table.artifactComponentId],
       foreignColumns: [
@@ -397,18 +379,18 @@ var tools = sqliteCore.sqliteTable(
 var functionTools = sqliteCore.sqliteTable(
   "function_tools",
   {
-    ...graphScoped,
+    ...agentScoped,
     name: sqliteCore.text("name").notNull(),
     description: sqliteCore.text("description"),
     functionId: sqliteCore.text("function_id").notNull(),
     ...timestamps
   },
   (table) => [
-    sqliteCore.primaryKey({ columns: [table.tenantId, table.projectId, table.graphId, table.id] }),
+    sqliteCore.primaryKey({ columns: [table.tenantId, table.projectId, table.agentId, table.id] }),
     sqliteCore.foreignKey({
-      columns: [table.tenantId, table.projectId, table.graphId],
-      foreignColumns: [agentGraph.tenantId, agentGraph.projectId, agentGraph.id],
-      name: "function_tools_graph_fk"
+      columns: [table.tenantId, table.projectId, table.agentId],
+      foreignColumns: [agents.tenantId, agents.projectId, agents.id],
+      name: "function_tools_agent_fk"
     }).onDelete("cascade"),
     // Foreign key constraint to functions table
     sqliteCore.foreignKey({
@@ -446,14 +428,12 @@ var subAgentToolRelations = sqliteCore.sqliteTable(
     ...timestamps
   },
   (table) => [
-    sqliteCore.primaryKey({ columns: [table.tenantId, table.projectId, table.graphId, table.id] }),
-    // Foreign key constraint to agents table (which includes project and graph scope)
+    sqliteCore.primaryKey({ columns: [table.tenantId, table.projectId, table.agentId, table.id] }),
     sqliteCore.foreignKey({
-      columns: [table.tenantId, table.projectId, table.graphId, table.subAgentId],
-      foreignColumns: [subAgents.tenantId, subAgents.projectId, subAgents.graphId, subAgents.id],
+      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"),
-    // Foreign key constraint to tools table (MCP tools)
     sqliteCore.foreignKey({
       columns: [table.tenantId, table.projectId, table.toolId],
       foreignColumns: [tools.tenantId, tools.projectId, tools.id],
@@ -469,20 +449,20 @@ var agentFunctionToolRelations = sqliteCore.sqliteTable(
     ...timestamps
   },
   (table) => [
-    sqliteCore.primaryKey({ columns: [table.tenantId, table.projectId, table.graphId, table.id] }),
+    sqliteCore.primaryKey({ columns: [table.tenantId, table.projectId, table.agentId, table.id] }),
     // Foreign key constraint to agents table
     sqliteCore.foreignKey({
-      columns: [table.tenantId, table.projectId, table.graphId, table.subAgentId],
-      foreignColumns: [subAgents.tenantId, subAgents.projectId, subAgents.graphId, subAgents.id],
+      columns: [table.tenantId, table.projectId, table.agentId, table.subAgentId],
+      foreignColumns: [subAgents.tenantId, subAgents.projectId, subAgents.agentId, subAgents.id],
       name: "agent_function_tool_relations_agent_fk"
     }).onDelete("cascade"),
     // Foreign key constraint to functionTools table
     sqliteCore.foreignKey({
-      columns: [table.tenantId, table.projectId, table.graphId, table.functionToolId],
+      columns: [table.tenantId, table.projectId, table.agentId, table.functionToolId],
       foreignColumns: [
         functionTools.tenantId,
         functionTools.projectId,
-        functionTools.graphId,
+        functionTools.agentId,
         functionTools.id
       ],
       name: "agent_function_tool_relations_function_tool_fk"
@@ -516,33 +496,23 @@ var messages = sqliteCore.sqliteTable(
     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)
     fromSubAgentId: sqliteCore.text("from_sub_agent_id"),
-    // Populated when message is from an agent
     toSubAgentId: sqliteCore.text("to_sub_agent_id"),
-    // Populated when message is directed to a specific agent (e.g., transfers/delegations)
     // External agent sender tracking
     fromExternalAgentId: sqliteCore.text("from_external_sub_agent_id"),
-    // Populated when message is directed from an external agent
     // External agent recipient tracking
     toExternalAgentId: sqliteCore.text("to_external_sub_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'
     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(),
     ...timestamps
@@ -563,7 +533,6 @@ var ledgerArtifacts = sqliteCore.sqliteTable(
     // Links
     taskId: sqliteCore.text("task_id").notNull(),
     toolCallId: sqliteCore.text("tool_call_id"),
-    // Added for traceability to the specific tool execution
     contextId: sqliteCore.text("context_id").notNull(),
     // Core Artifact fields
     type: sqliteCore.text("type").notNull().default("source"),
@@ -599,13 +568,10 @@ var ledgerArtifacts = sqliteCore.sqliteTable(
 var apiKeys = sqliteCore.sqliteTable(
   "api_keys",
   {
-    ...graphScoped,
+    ...agentScoped,
     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...")
     name: sqliteCore.text("name"),
     lastUsedAt: sqliteCore.text("last_used_at"),
     expiresAt: sqliteCore.text("expires_at"),
@@ -618,11 +584,11 @@ var apiKeys = sqliteCore.sqliteTable(
       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"
+      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_graph_idx").on(t.tenantId, t.graphId),
+    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)
   ]
@@ -632,9 +598,7 @@ var credentialReferences = sqliteCore.sqliteTable(
   {
     ...projectScoped,
     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(),
     ...timestamps
   },
@@ -648,7 +612,6 @@ var credentialReferences = sqliteCore.sqliteTable(
   ]
 );
 drizzleOrm.relations(tasks, ({ one, many }) => ({
-  // A task belongs to one project
   project: one(projects, {
     fields: [tasks.tenantId, tasks.projectId],
     references: [projects.tenantId, projects.id]
@@ -665,14 +628,12 @@ drizzleOrm.relations(tasks, ({ one, many }) => ({
     fields: [tasks.subAgentId],
     references: [subAgents.id]
   }),
-  // A task can have many messages associated with it
   messages: many(messages),
-  // A task can have many ledger artifacts
   ledgerArtifacts: many(ledgerArtifacts)
 }));
 drizzleOrm.relations(projects, ({ many }) => ({
   subAgents: many(subAgents),
-  agentGraphs: many(agentGraph),
+  agents: many(agents),
   tools: many(tools),
   functions: many(functions),
   contextConfigs: many(contextConfigs),
@@ -701,7 +662,7 @@ drizzleOrm.relations(contextConfigs, ({ many, one }) => ({
     fields: [contextConfigs.tenantId, contextConfigs.projectId],
     references: [projects.tenantId, projects.id]
   }),
-  graphs: many(agentGraph),
+  agents: many(agents),
   cache: many(contextCache)
 }));
 drizzleOrm.relations(contextCache, ({ one }) => ({
@@ -716,7 +677,7 @@ drizzleOrm.relations(subAgents, ({ many, one }) => ({
     references: [projects.tenantId, projects.id]
   }),
   tasks: many(tasks),
-  defaultForGraphs: many(agentGraph),
+  defaultForAgents: many(agents),
   sourceRelations: many(subAgentRelations, {
     relationName: "sourceRelations"
   }),
@@ -729,25 +690,22 @@ drizzleOrm.relations(subAgents, ({ many, one }) => ({
   receivedMessages: many(messages, {
     relationName: "receivedMessages"
   }),
-  associatedMessages: many(messages, {
-    relationName: "associatedAgent"
-  }),
   toolRelations: many(subAgentToolRelations),
   functionToolRelations: many(agentFunctionToolRelations),
   dataComponentRelations: many(subAgentDataComponents),
   artifactComponentRelations: many(subAgentArtifactComponents)
 }));
-drizzleOrm.relations(agentGraph, ({ one, many }) => ({
+drizzleOrm.relations(agents, ({ one, many }) => ({
   project: one(projects, {
-    fields: [agentGraph.tenantId, agentGraph.projectId],
+    fields: [agents.tenantId, agents.projectId],
     references: [projects.tenantId, projects.id]
   }),
   defaultSubAgent: one(subAgents, {
-    fields: [agentGraph.defaultSubAgentId],
+    fields: [agents.defaultSubAgentId],
     references: [subAgents.id]
   }),
   contextConfig: one(contextConfigs, {
-    fields: [agentGraph.contextConfigId],
+    fields: [agents.contextConfigId],
     references: [contextConfigs.id]
   }),
   functionTools: many(functionTools)
@@ -768,9 +726,9 @@ drizzleOrm.relations(apiKeys, ({ one }) => ({
     fields: [apiKeys.tenantId, apiKeys.projectId],
     references: [projects.tenantId, projects.id]
   }),
-  graph: one(agentGraph, {
-    fields: [apiKeys.graphId],
-    references: [agentGraph.id]
+  agent: one(agents, {
+    fields: [apiKeys.agentId],
+    references: [agents.id]
   })
 }));
 drizzleOrm.relations(subAgentToolRelations, ({ one }) => ({
@@ -783,8 +741,13 @@ drizzleOrm.relations(subAgentToolRelations, ({ one }) => ({
     references: [tools.id]
   })
 }));
-drizzleOrm.relations(credentialReferences, ({ many }) => ({
-  tools: many(tools)
+drizzleOrm.relations(credentialReferences, ({ one, many }) => ({
+  project: one(projects, {
+    fields: [credentialReferences.tenantId, credentialReferences.projectId],
+    references: [projects.tenantId, projects.id]
+  }),
+  tools: many(tools),
+  externalAgents: many(externalAgents)
 }));
 drizzleOrm.relations(tools, ({ one, many }) => ({
   project: one(projects, {
@@ -893,13 +856,17 @@ drizzleOrm.relations(ledgerArtifacts, ({ one }) => ({
     references: [tasks.id]
   })
 }));
-drizzleOrm.relations(functions, ({ many }) => ({
-  functionTools: many(functionTools)
+drizzleOrm.relations(functions, ({ many, one }) => ({
+  functionTools: many(functionTools),
+  project: one(projects, {
+    fields: [functions.tenantId, functions.projectId],
+    references: [projects.tenantId, projects.id]
+  })
 }));
 drizzleOrm.relations(subAgentRelations, ({ one }) => ({
-  graph: one(agentGraph, {
-    fields: [subAgentRelations.graphId],
-    references: [agentGraph.id]
+  agent: one(agents, {
+    fields: [subAgentRelations.agentId],
+    references: [agents.id]
   }),
   sourceSubAgent: one(subAgents, {
     fields: [subAgentRelations.sourceSubAgentId],
@@ -921,9 +888,9 @@ drizzleOrm.relations(functionTools, ({ one, many }) => ({
     fields: [functionTools.tenantId, functionTools.projectId],
     references: [projects.tenantId, projects.id]
   }),
-  graph: one(agentGraph, {
-    fields: [functionTools.tenantId, functionTools.projectId, functionTools.graphId],
-    references: [agentGraph.tenantId, agentGraph.projectId, agentGraph.id]
+  agent: one(agents, {
+    fields: [functionTools.tenantId, functionTools.projectId, functionTools.agentId],
+    references: [agents.tenantId, agents.projectId, agents.id]
   }),
   function: one(functions, {
     fields: [functionTools.tenantId, functionTools.projectId, functionTools.functionId],
@@ -966,9 +933,13 @@ var CredentialStoreType = {
 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 SubAgentStopWhenSchema = StopWhenSchema.pick({ stepCountIs: true });
+}).openapi("StopWhen");
+var AgentStopWhenSchema = StopWhenSchema.pick({ transferCountIs: true }).openapi(
+  "AgentStopWhen"
+);
+var SubAgentStopWhenSchema = StopWhenSchema.pick({ stepCountIs: true }).openapi(
+  "SubAgentStopWhen"
+);
 var MIN_ID_LENGTH = 1;
 var MAX_ID_LENGTH = 255;
 var URL_SAFE_ID_PATTERN = /^[a-zA-Z0-9\-_.]+$/;
@@ -981,23 +952,23 @@ var resourceIdSchema = zodOpenapi.z.string().min(MIN_ID_LENGTH).max(MAX_ID_LENGT
 var ModelSettingsSchema = zodOpenapi.z.object({
   model: zodOpenapi.z.string().optional(),
   providerOptions: zodOpenapi.z.record(zodOpenapi.z.string(), zodOpenapi.z.any()).optional()
-});
+}).openapi("ModelSettings");
 var ModelSchema = zodOpenapi.z.object({
   base: ModelSettingsSchema.optional(),
   structuredOutput: ModelSettingsSchema.optional(),
   summarizer: ModelSettingsSchema.optional()
-});
+}).openapi("Model");
 var ProjectModelSchema = zodOpenapi.z.object({
   base: ModelSettingsSchema,
   structuredOutput: ModelSettingsSchema.optional(),
   summarizer: ModelSettingsSchema.optional()
-});
+}).openapi("ProjectModel");
 var SandboxConfigSchema = zodOpenapi.z.object({
   provider: zodOpenapi.z.enum(["vercel", "local"]),
   runtime: zodOpenapi.z.enum(["node22", "typescript"]),
   timeout: zodOpenapi.z.number().min(1e3).max(3e5).optional(),
   vcpus: zodOpenapi.z.number().min(1).max(8).optional()
-});
+}).openapi("SandboxConfig");
 var FunctionToolConfigSchema = zodOpenapi.z.object({
   name: zodOpenapi.z.string(),
   description: zodOpenapi.z.string(),
@@ -1008,31 +979,37 @@ var FunctionToolConfigSchema = zodOpenapi.z.object({
 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 createGraphScopedApiSchema = (schema) => schema.omit({ tenantId: true, projectId: true, graphId: true });
-var createGraphScopedApiInsertSchema = (schema) => schema.omit({ tenantId: true, projectId: true, graphId: true });
-var createGraphScopedApiUpdateSchema = (schema) => schema.omit({ tenantId: true, projectId: true, graphId: true }).partial();
+var createAgentScopedApiSchema = (schema) => schema.omit({ tenantId: true, projectId: true, agentId: true });
+var createAgentScopedApiInsertSchema = (schema) => schema.omit({ tenantId: true, projectId: true, agentId: true });
+var createAgentScopedApiUpdateSchema = (schema) => schema.omit({ tenantId: true, projectId: true, agentId: true }).partial();
 var SubAgentSelectSchema = drizzleZod.createSelectSchema(subAgents);
 var SubAgentInsertSchema = drizzleZod.createInsertSchema(subAgents).extend({
   id: resourceIdSchema,
   models: ModelSchema.optional()
 });
 var SubAgentUpdateSchema = SubAgentInsertSchema.partial();
-var SubAgentApiSelectSchema = createGraphScopedApiSchema(SubAgentSelectSchema);
-var SubAgentApiInsertSchema = createGraphScopedApiInsertSchema(SubAgentInsertSchema);
-var SubAgentApiUpdateSchema = createGraphScopedApiUpdateSchema(SubAgentUpdateSchema);
+var SubAgentApiSelectSchema = createAgentScopedApiSchema(SubAgentSelectSchema).openapi(
+  "SubAgent"
+);
+var SubAgentApiInsertSchema = createAgentScopedApiInsertSchema(
+  SubAgentInsertSchema
+).openapi("SubAgentCreate");
+var SubAgentApiUpdateSchema = createAgentScopedApiUpdateSchema(
+  SubAgentUpdateSchema
+).openapi("SubAgentUpdate");
 var SubAgentRelationSelectSchema = drizzleZod.createSelectSchema(subAgentRelations);
 var SubAgentRelationInsertSchema = drizzleZod.createInsertSchema(subAgentRelations).extend({
   id: resourceIdSchema,
-  graphId: resourceIdSchema,
+  agentId: resourceIdSchema,
   sourceSubAgentId: resourceIdSchema,
   targetSubAgentId: resourceIdSchema.optional(),
   externalSubAgentId: resourceIdSchema.optional()
 });
 var SubAgentRelationUpdateSchema = SubAgentRelationInsertSchema.partial();
-var SubAgentRelationApiSelectSchema = createGraphScopedApiSchema(
+var SubAgentRelationApiSelectSchema = createAgentScopedApiSchema(
   SubAgentRelationSelectSchema
-);
-var SubAgentRelationApiInsertSchema = createGraphScopedApiInsertSchema(
+).openapi("SubAgentRelation");
+var SubAgentRelationApiInsertSchema = createAgentScopedApiInsertSchema(
   SubAgentRelationInsertSchema
 ).extend({
   relationType: zodOpenapi.z.enum(VALID_RELATION_TYPES)
@@ -1046,8 +1023,8 @@ var SubAgentRelationApiInsertSchema = createGraphScopedApiInsertSchema(
     message: "Must specify exactly one of targetSubAgentId or externalSubAgentId",
     path: ["targetSubAgentId", "externalSubAgentId"]
   }
-);
-var SubAgentRelationApiUpdateSchema = createGraphScopedApiUpdateSchema(
+).openapi("SubAgentRelationCreate");
+var SubAgentRelationApiUpdateSchema = createAgentScopedApiUpdateSchema(
   SubAgentRelationUpdateSchema
 ).extend({
   relationType: zodOpenapi.z.enum(VALID_RELATION_TYPES).optional()
@@ -1064,7 +1041,7 @@ var SubAgentRelationApiUpdateSchema = createGraphScopedApiUpdateSchema(
     message: "Must specify exactly one of targetSubAgentId or externalSubAgentId when updating sub-agent relationships",
     path: ["targetSubAgentId", "externalSubAgentId"]
   }
-);
+).openapi("SubAgentRelationUpdate");
 var SubAgentRelationQuerySchema = zodOpenapi.z.object({
   sourceSubAgentId: zodOpenapi.z.string().optional(),
   targetSubAgentId: zodOpenapi.z.string().optional(),
@@ -1072,23 +1049,25 @@ var SubAgentRelationQuerySchema = zodOpenapi.z.object({
 });
 var ExternalSubAgentRelationInsertSchema = drizzleZod.createInsertSchema(subAgentRelations).extend({
   id: resourceIdSchema,
-  graphId: resourceIdSchema,
+  agentId: resourceIdSchema,
   sourceSubAgentId: resourceIdSchema,
   externalSubAgentId: resourceIdSchema
 });
 var ExternalSubAgentRelationApiInsertSchema = createApiInsertSchema(
   ExternalSubAgentRelationInsertSchema
 );
-var AgentGraphSelectSchema = drizzleZod.createSelectSchema(agentGraph);
-var AgentGraphInsertSchema = drizzleZod.createInsertSchema(agentGraph).extend({
+var AgentSelectSchema = drizzleZod.createSelectSchema(agents);
+var AgentInsertSchema = drizzleZod.createInsertSchema(agents).extend({
   id: resourceIdSchema
 });
-var AgentGraphUpdateSchema = AgentGraphInsertSchema.partial();
-var AgentGraphApiSelectSchema = createApiSchema(AgentGraphSelectSchema);
-var AgentGraphApiInsertSchema = createApiInsertSchema(AgentGraphInsertSchema).extend({
+var AgentUpdateSchema = AgentInsertSchema.partial();
+var AgentApiSelectSchema = createApiSchema(AgentSelectSchema).openapi("Agent");
+var AgentApiInsertSchema = createApiInsertSchema(AgentInsertSchema).extend({
   id: resourceIdSchema
-});
-var AgentGraphApiUpdateSchema = createApiUpdateSchema(AgentGraphUpdateSchema);
+}).openapi("AgentCreate");
+var AgentApiUpdateSchema = createApiUpdateSchema(AgentUpdateSchema).openapi(
+  "AgentUpdate"
+);
 var TaskSelectSchema = drizzleZod.createSelectSchema(tasks);
 var TaskInsertSchema = drizzleZod.createInsertSchema(tasks).extend({
   id: resourceIdSchema,
@@ -1131,9 +1110,12 @@ 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(),
+  reconnectionOptions: zodOpenapi.z.any().optional().openapi({
+    type: "object",
+    description: "Reconnection options for streamable HTTP transport"
+  }),
   sessionId: zodOpenapi.z.string().optional()
-});
+}).openapi("McpTransportConfig");
 var ToolStatusSchema = zodOpenapi.z.enum(TOOL_STATUS_VALUES);
 var McpToolDefinitionSchema = zodOpenapi.z.object({
   name: zodOpenapi.z.string(),
@@ -1148,13 +1130,16 @@ var ToolInsertSchema = drizzleZod.createInsertSchema(tools).extend({
     type: zodOpenapi.z.literal("mcp"),
     mcp: zodOpenapi.z.object({
       server: zodOpenapi.z.object({
-        url: zodOpenapi.z.string().url()
+        url: zodOpenapi.z.url()
       }),
       transport: 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(),
+        reconnectionOptions: zodOpenapi.z.any().optional().openapi({
+          type: "object",
+          description: "Reconnection options for streamable HTTP transport"
+        }),
         sessionId: zodOpenapi.z.string().optional()
       }).optional(),
       activeTools: zodOpenapi.z.array(zodOpenapi.z.string()).optional()
@@ -1167,9 +1152,15 @@ var ConversationInsertSchema = drizzleZod.createInsertSchema(conversations).exte
   contextConfigId: resourceIdSchema.optional()
 });
 var ConversationUpdateSchema = ConversationInsertSchema.partial();
-var ConversationApiSelectSchema = createApiSchema(ConversationSelectSchema);
-var ConversationApiInsertSchema = createApiInsertSchema(ConversationInsertSchema);
-var ConversationApiUpdateSchema = createApiUpdateSchema(ConversationUpdateSchema);
+var ConversationApiSelectSchema = createApiSchema(ConversationSelectSchema).openapi(
+  "Conversation"
+);
+var ConversationApiInsertSchema = createApiInsertSchema(ConversationInsertSchema).openapi(
+  "ConversationCreate"
+);
+var ConversationApiUpdateSchema = createApiUpdateSchema(ConversationUpdateSchema).openapi(
+  "ConversationUpdate"
+);
 var MessageSelectSchema = drizzleZod.createSelectSchema(messages);
 var MessageInsertSchema = drizzleZod.createInsertSchema(messages).extend({
   id: resourceIdSchema,
@@ -1177,9 +1168,13 @@ var MessageInsertSchema = drizzleZod.createInsertSchema(messages).extend({
   taskId: resourceIdSchema.optional()
 });
 var MessageUpdateSchema = MessageInsertSchema.partial();
-var MessageApiSelectSchema = createApiSchema(MessageSelectSchema);
-var MessageApiInsertSchema = createApiInsertSchema(MessageInsertSchema);
-var MessageApiUpdateSchema = createApiUpdateSchema(MessageUpdateSchema);
+var MessageApiSelectSchema = createApiSchema(MessageSelectSchema).openapi("Message");
+var MessageApiInsertSchema = createApiInsertSchema(MessageInsertSchema).openapi(
+  "MessageCreate"
+);
+var MessageApiUpdateSchema = createApiUpdateSchema(MessageUpdateSchema).openapi(
+  "MessageUpdate"
+);
 var ContextCacheSelectSchema = drizzleZod.createSelectSchema(contextCache);
 var ContextCacheInsertSchema = drizzleZod.createInsertSchema(contextCache);
 var ContextCacheUpdateSchema = ContextCacheInsertSchema.partial();
@@ -1195,13 +1190,19 @@ var DataComponentBaseSchema = DataComponentInsertSchema.omit({
   updatedAt: true
 });
 var DataComponentUpdateSchema = DataComponentInsertSchema.partial();
-var DataComponentApiSelectSchema = createApiSchema(DataComponentSelectSchema);
-var DataComponentApiInsertSchema = createApiInsertSchema(DataComponentInsertSchema);
-var DataComponentApiUpdateSchema = createApiUpdateSchema(DataComponentUpdateSchema);
+var DataComponentApiSelectSchema = createApiSchema(
+  DataComponentSelectSchema
+).openapi("DataComponent");
+var DataComponentApiInsertSchema = createApiInsertSchema(
+  DataComponentInsertSchema
+).openapi("DataComponentCreate");
+var DataComponentApiUpdateSchema = createApiUpdateSchema(
+  DataComponentUpdateSchema
+).openapi("DataComponentUpdate");
 var SubAgentDataComponentSelectSchema = drizzleZod.createSelectSchema(subAgentDataComponents);
 var SubAgentDataComponentInsertSchema = drizzleZod.createInsertSchema(subAgentDataComponents);
 var SubAgentDataComponentUpdateSchema = SubAgentDataComponentInsertSchema.partial();
-var SubAgentDataComponentApiSelectSchema = createGraphScopedApiSchema(
+var SubAgentDataComponentApiSelectSchema = createAgentScopedApiSchema(
   SubAgentDataComponentSelectSchema
 );
 var SubAgentDataComponentApiInsertSchema = SubAgentDataComponentInsertSchema.omit({
@@ -1210,7 +1211,7 @@ var SubAgentDataComponentApiInsertSchema = SubAgentDataComponentInsertSchema.omi
   id: true,
   createdAt: true
 });
-var SubAgentDataComponentApiUpdateSchema = createGraphScopedApiUpdateSchema(
+var SubAgentDataComponentApiUpdateSchema = createAgentScopedApiUpdateSchema(
   SubAgentDataComponentUpdateSchema
 );
 var ArtifactComponentSelectSchema = drizzleZod.createSelectSchema(artifactComponents);
@@ -1218,16 +1219,18 @@ var ArtifactComponentInsertSchema = drizzleZod.createInsertSchema(artifactCompon
   id: resourceIdSchema
 });
 var ArtifactComponentUpdateSchema = ArtifactComponentInsertSchema.partial();
-var ArtifactComponentApiSelectSchema = createApiSchema(ArtifactComponentSelectSchema);
+var ArtifactComponentApiSelectSchema = createApiSchema(
+  ArtifactComponentSelectSchema
+).openapi("ArtifactComponent");
 var ArtifactComponentApiInsertSchema = ArtifactComponentInsertSchema.omit({
   tenantId: true,
   projectId: true,
   createdAt: true,
   updatedAt: true
-});
+}).openapi("ArtifactComponentCreate");
 var ArtifactComponentApiUpdateSchema = createApiUpdateSchema(
   ArtifactComponentUpdateSchema
-);
+).openapi("ArtifactComponentUpdate");
 var SubAgentArtifactComponentSelectSchema = drizzleZod.createSelectSchema(subAgentArtifactComponents);
 var SubAgentArtifactComponentInsertSchema = drizzleZod.createInsertSchema(
   subAgentArtifactComponents
@@ -1237,7 +1240,7 @@ var SubAgentArtifactComponentInsertSchema = drizzleZod.createInsertSchema(
   artifactComponentId: resourceIdSchema
 });
 var SubAgentArtifactComponentUpdateSchema = SubAgentArtifactComponentInsertSchema.partial();
-var SubAgentArtifactComponentApiSelectSchema = createGraphScopedApiSchema(
+var SubAgentArtifactComponentApiSelectSchema = createAgentScopedApiSchema(
   SubAgentArtifactComponentSelectSchema
 );
 var SubAgentArtifactComponentApiInsertSchema = SubAgentArtifactComponentInsertSchema.omit({
@@ -1246,7 +1249,7 @@ var SubAgentArtifactComponentApiInsertSchema = SubAgentArtifactComponentInsertSc
   id: true,
   createdAt: true
 });
-var SubAgentArtifactComponentApiUpdateSchema = createGraphScopedApiUpdateSchema(
+var SubAgentArtifactComponentApiUpdateSchema = createAgentScopedApiUpdateSchema(
   SubAgentArtifactComponentUpdateSchema
 );
 var ExternalAgentSelectSchema = drizzleZod.createSelectSchema(externalAgents).extend({
@@ -1257,9 +1260,15 @@ var ExternalAgentInsertSchema = drizzleZod.createInsertSchema(externalAgents).ex
   id: resourceIdSchema
 });
 var ExternalAgentUpdateSchema = ExternalAgentInsertSchema.partial();
-var ExternalAgentApiSelectSchema = createGraphScopedApiSchema(ExternalAgentSelectSchema);
-var ExternalAgentApiInsertSchema = createGraphScopedApiInsertSchema(ExternalAgentInsertSchema);
-var ExternalAgentApiUpdateSchema = createGraphScopedApiUpdateSchema(ExternalAgentUpdateSchema);
+var ExternalAgentApiSelectSchema = createAgentScopedApiSchema(
+  ExternalAgentSelectSchema
+).openapi("ExternalAgent");
+var ExternalAgentApiInsertSchema = createAgentScopedApiInsertSchema(
+  ExternalAgentInsertSchema
+).openapi("ExternalAgentCreate");
+var ExternalAgentApiUpdateSchema = createAgentScopedApiUpdateSchema(
+  ExternalAgentUpdateSchema
+).openapi("ExternalAgentUpdate");
 var AllAgentSchema = zodOpenapi.z.discriminatedUnion("type", [
   SubAgentApiSelectSchema.extend({ type: zodOpenapi.z.literal("internal") }),
   ExternalAgentApiSelectSchema.extend({ type: zodOpenapi.z.literal("external") })
@@ -1267,7 +1276,7 @@ var AllAgentSchema = zodOpenapi.z.discriminatedUnion("type", [
 var ApiKeySelectSchema = drizzleZod.createSelectSchema(apiKeys);
 var ApiKeyInsertSchema = drizzleZod.createInsertSchema(apiKeys).extend({
   id: resourceIdSchema,
-  graphId: resourceIdSchema
+  agentId: resourceIdSchema
 });
 var ApiKeyUpdateSchema = ApiKeyInsertSchema.partial().omit({
   tenantId: true,
@@ -1283,7 +1292,7 @@ var ApiKeyApiSelectSchema = ApiKeySelectSchema.omit({
   projectId: true,
   keyHash: true
   // Never expose the hash
-});
+}).openapi("ApiKey");
 var ApiKeyApiCreationResponseSchema = zodOpenapi.z.object({
   data: zodOpenapi.z.object({
     apiKey: ApiKeyApiSelectSchema,
@@ -1303,8 +1312,8 @@ var ApiKeyApiInsertSchema = ApiKeyInsertSchema.omit({
   // Auto-generated
   lastUsedAt: true
   // Not set on creation
-});
-var ApiKeyApiUpdateSchema = ApiKeyUpdateSchema;
+}).openapi("ApiKeyCreate");
+var ApiKeyApiUpdateSchema = ApiKeyUpdateSchema.openapi("ApiKeyUpdate");
 var CredentialReferenceSelectSchema = zodOpenapi.z.object({
   id: zodOpenapi.z.string(),
   tenantId: zodOpenapi.z.string(),
@@ -1327,17 +1336,17 @@ var CredentialReferenceApiSelectSchema = createApiSchema(
 ).extend({
   type: zodOpenapi.z.enum(CredentialStoreType),
   tools: zodOpenapi.z.array(ToolSelectSchema).optional()
-});
+}).openapi("CredentialReference");
 var CredentialReferenceApiInsertSchema = createApiInsertSchema(
   CredentialReferenceInsertSchema
 ).extend({
   type: zodOpenapi.z.enum(CredentialStoreType)
-});
+}).openapi("CredentialReferenceCreate");
 var CredentialReferenceApiUpdateSchema = createApiUpdateSchema(
   CredentialReferenceUpdateSchema
 ).extend({
   type: zodOpenapi.z.enum(CredentialStoreType).optional()
-});
+}).openapi("CredentialReferenceUpdate");
 var McpToolSchema = ToolInsertSchema.extend({
   imageUrl: imageUrlSchema,
   availableTools: zodOpenapi.z.array(McpToolDefinitionSchema).optional(),
@@ -1366,25 +1375,35 @@ var MCPToolConfigSchema = McpToolSchema.omit({
   credential: CredentialReferenceApiInsertSchema.optional()
 });
 var ToolUpdateSchema = ToolInsertSchema.partial();
-var ToolApiSelectSchema = createApiSchema(ToolSelectSchema);
-var ToolApiInsertSchema = createApiInsertSchema(ToolInsertSchema);
-var ToolApiUpdateSchema = createApiUpdateSchema(ToolUpdateSchema);
+var ToolApiSelectSchema = createApiSchema(ToolSelectSchema).openapi("Tool");
+var ToolApiInsertSchema = createApiInsertSchema(ToolInsertSchema).openapi("ToolCreate");
+var ToolApiUpdateSchema = createApiUpdateSchema(ToolUpdateSchema).openapi("ToolUpdate");
 var FunctionToolSelectSchema = drizzleZod.createSelectSchema(functionTools);
 var FunctionToolInsertSchema = drizzleZod.createInsertSchema(functionTools).extend({
   id: resourceIdSchema
 });
 var FunctionToolUpdateSchema = FunctionToolInsertSchema.partial();
-var FunctionToolApiSelectSchema = createApiSchema(FunctionToolSelectSchema);
-var FunctionToolApiInsertSchema = createGraphScopedApiInsertSchema(FunctionToolInsertSchema);
-var FunctionToolApiUpdateSchema = createApiUpdateSchema(FunctionToolUpdateSchema);
+var FunctionToolApiSelectSchema = createApiSchema(FunctionToolSelectSchema).openapi(
+  "FunctionTool"
+);
+var FunctionToolApiInsertSchema = createAgentScopedApiInsertSchema(
+  FunctionToolInsertSchema
+).openapi("FunctionToolCreate");
+var FunctionToolApiUpdateSchema = createApiUpdateSchema(
+  FunctionToolUpdateSchema
+).openapi("FunctionToolUpdate");
 var FunctionSelectSchema = drizzleZod.createSelectSchema(functions);
 var FunctionInsertSchema = drizzleZod.createInsertSchema(functions).extend({
   id: resourceIdSchema
 });
 var FunctionUpdateSchema = FunctionInsertSchema.partial();
-var FunctionApiSelectSchema = createApiSchema(FunctionSelectSchema);
-var FunctionApiInsertSchema = createApiInsertSchema(FunctionInsertSchema);
-var FunctionApiUpdateSchema = createApiUpdateSchema(FunctionUpdateSchema);
+var FunctionApiSelectSchema = createApiSchema(FunctionSelectSchema).openapi("Function");
+var FunctionApiInsertSchema = createApiInsertSchema(FunctionInsertSchema).openapi(
+  "FunctionCreate"
+);
+var FunctionApiUpdateSchema = createApiUpdateSchema(FunctionUpdateSchema).openapi(
+  "FunctionUpdate"
+);
 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"),
@@ -1393,7 +1412,7 @@ var FetchConfigSchema = zodOpenapi.z.object({
   transform: zodOpenapi.z.string().optional(),
   // JSONPath or JS transform function
   timeout: zodOpenapi.z.number().min(0).optional().default(1e4).optional()
-});
+}).openapi("FetchConfig");
 var FetchDefinitionSchema = zodOpenapi.z.object({
   id: zodOpenapi.z.string().min(1, "Fetch definition ID is required"),
   name: zodOpenapi.z.string().optional(),
@@ -1401,29 +1420,41 @@ var FetchDefinitionSchema = zodOpenapi.z.object({
   fetchConfig: FetchConfigSchema,
   responseSchema: zodOpenapi.z.any().optional(),
   // JSON Schema for validating HTTP response
-  defaultValue: zodOpenapi.z.unknown().optional(),
+  defaultValue: zodOpenapi.z.any().optional().openapi({
+    description: "Default value if fetch fails"
+  }),
   credential: CredentialReferenceApiInsertSchema.optional()
-});
+}).openapi("FetchDefinition");
 var ContextConfigSelectSchema = drizzleZod.createSelectSchema(contextConfigs).extend({
-  headersSchema: zodOpenapi.z.unknown().optional()
+  headersSchema: zodOpenapi.z.any().optional().openapi({
+    type: "object",
+    description: "JSON Schema for validating request headers"
+  })
 });
 var ContextConfigInsertSchema = drizzleZod.createInsertSchema(contextConfigs).extend({
   id: resourceIdSchema.optional(),
-  headersSchema: zodOpenapi.z.unknown().optional()
+  headersSchema: zodOpenapi.z.any().nullable().optional().openapi({
+    type: "object",
+    description: "JSON Schema for validating request headers"
+  }),
+  contextVariables: zodOpenapi.z.any().nullable().optional().openapi({
+    type: "object",
+    description: "Context variables configuration with fetch definitions"
+  })
 }).omit({
   createdAt: true,
   updatedAt: true
 });
 var ContextConfigUpdateSchema = ContextConfigInsertSchema.partial();
 var ContextConfigApiSelectSchema = createApiSchema(ContextConfigSelectSchema).omit({
-  graphId: true
-});
+  agentId: true
+}).openapi("ContextConfig");
 var ContextConfigApiInsertSchema = createApiInsertSchema(ContextConfigInsertSchema).omit({
-  graphId: true
-});
+  agentId: true
+}).openapi("ContextConfigCreate");
 var ContextConfigApiUpdateSchema = createApiUpdateSchema(ContextConfigUpdateSchema).omit({
-  graphId: true
-});
+  agentId: true
+}).openapi("ContextConfigUpdate");
 var SubAgentToolRelationSelectSchema = drizzleZod.createSelectSchema(subAgentToolRelations);
 var SubAgentToolRelationInsertSchema = drizzleZod.createInsertSchema(subAgentToolRelations).extend({
   id: resourceIdSchema,
@@ -1433,15 +1464,15 @@ var SubAgentToolRelationInsertSchema = drizzleZod.createInsertSchema(subAgentToo
   headers: zodOpenapi.z.record(zodOpenapi.z.string(), zodOpenapi.z.string()).nullish()
 });
 var SubAgentToolRelationUpdateSchema = SubAgentToolRelationInsertSchema.partial();
-var SubAgentToolRelationApiSelectSchema = createGraphScopedApiSchema(
+var SubAgentToolRelationApiSelectSchema = createAgentScopedApiSchema(
   SubAgentToolRelationSelectSchema
-);
-var SubAgentToolRelationApiInsertSchema = createGraphScopedApiInsertSchema(
+).openapi("SubAgentToolRelation");
+var SubAgentToolRelationApiInsertSchema = createAgentScopedApiInsertSchema(
   SubAgentToolRelationInsertSchema
-);
-var SubAgentToolRelationApiUpdateSchema = createGraphScopedApiUpdateSchema(
+).openapi("SubAgentToolRelationCreate");
+var SubAgentToolRelationApiUpdateSchema = createAgentScopedApiUpdateSchema(
   SubAgentToolRelationUpdateSchema
-);
+).openapi("SubAgentToolRelationUpdate");
 var LedgerArtifactSelectSchema = drizzleZod.createSelectSchema(ledgerArtifacts);
 var LedgerArtifactInsertSchema = drizzleZod.createInsertSchema(ledgerArtifacts);
 var LedgerArtifactUpdateSchema = LedgerArtifactInsertSchema.partial();
@@ -1456,21 +1487,21 @@ var StatusComponentSchema = zodOpenapi.z.object({
     properties: zodOpenapi.z.record(zodOpenapi.z.string(), zodOpenapi.z.any()),
     required: zodOpenapi.z.array(zodOpenapi.z.string()).optional()
   }).optional()
-});
+}).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(),
   statusComponents: zodOpenapi.z.array(StatusComponentSchema).optional()
-});
+}).openapi("StatusUpdate");
 var CanUseItemSchema = zodOpenapi.z.object({
   agentToolRelationId: zodOpenapi.z.string().optional(),
   toolId: zodOpenapi.z.string(),
   toolSelection: zodOpenapi.z.array(zodOpenapi.z.string()).nullish(),
   headers: zodOpenapi.z.record(zodOpenapi.z.string(), zodOpenapi.z.string()).nullish()
-});
-var FullGraphAgentInsertSchema = SubAgentApiInsertSchema.extend({
+}).openapi("CanUseItem");
+var FullAgentAgentInsertSchema = SubAgentApiInsertSchema.extend({
   type: zodOpenapi.z.literal("internal"),
   canUse: zodOpenapi.z.array(CanUseItemSchema),
   // All tools (both MCP and function tools)
@@ -1479,51 +1510,30 @@ var FullGraphAgentInsertSchema = SubAgentApiInsertSchema.extend({
   canTransferTo: zodOpenapi.z.array(zodOpenapi.z.string()).optional(),
   canDelegateTo: zodOpenapi.z.array(zodOpenapi.z.string()).optional()
 });
-var FullGraphDefinitionSchema = AgentGraphApiInsertSchema.extend({
-  subAgents: zodOpenapi.z.record(
-    zodOpenapi.z.string(),
-    zodOpenapi.z.union([FullGraphAgentInsertSchema, ExternalAgentApiInsertSchema])
-  ),
-  // Lookup maps for UI to resolve canUse items
-  tools: zodOpenapi.z.record(zodOpenapi.z.string(), ToolApiInsertSchema).optional(),
-  // MCP tools (project-scoped)
-  functionTools: zodOpenapi.z.record(zodOpenapi.z.string(), FunctionToolApiInsertSchema).optional(),
-  // Function tools (graph-scoped)
-  functions: zodOpenapi.z.record(zodOpenapi.z.string(), FunctionApiInsertSchema).optional(),
-  // Get function code for function tools
-  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({
+var AgentWithinContextOfProjectSchema = AgentApiInsertSchema.extend({
   subAgents: zodOpenapi.z.record(
     zodOpenapi.z.string(),
-    zodOpenapi.z.discriminatedUnion("type", [
-      FullGraphAgentInsertSchema,
-      ExternalAgentApiInsertSchema.extend({ type: zodOpenapi.z.literal("external") })
-    ])
+    zodOpenapi.z.union([FullAgentAgentInsertSchema, ExternalAgentApiInsertSchema])
   ),
   // Lookup maps for UI to resolve canUse items
   tools: zodOpenapi.z.record(zodOpenapi.z.string(), ToolApiInsertSchema).optional(),
   // MCP tools (project-scoped)
   functionTools: zodOpenapi.z.record(zodOpenapi.z.string(), FunctionToolApiInsertSchema).optional(),
-  // Function tools (graph-scoped)
+  // Function tools (agent-scoped)
   functions: zodOpenapi.z.record(zodOpenapi.z.string(), FunctionApiInsertSchema).optional(),
   // Get function code for function tools
   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()
+  stopWhen: AgentStopWhenSchema.optional(),
+  prompt: zodOpenapi.z.string().max(5e3, "Agent prompt cannot exceed 5000 characters").optional()
 });
 var PaginationSchema = 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()
-});
+}).openapi("Pagination");
 var ListResponseSchema = (itemSchema) => zodOpenapi.z.object({
   data: zodOpenapi.z.array(itemSchema),
   pagination: PaginationSchema
@@ -1534,15 +1544,17 @@ var SingleResponseSchema = (itemSchema) => zodOpenapi.z.object({
 var ErrorResponseSchema = zodOpenapi.z.object({
   error: zodOpenapi.z.string(),
   message: zodOpenapi.z.string().optional(),
-  details: zodOpenapi.z.unknown().optional()
-});
+  details: zodOpenapi.z.any().optional().openapi({
+    description: "Additional error details"
+  })
+}).openapi("ErrorResponse");
 var ExistsResponseSchema = zodOpenapi.z.object({
   exists: zodOpenapi.z.boolean()
-});
+}).openapi("ExistsResponse");
 var RemovedResponseSchema = zodOpenapi.z.object({
   message: zodOpenapi.z.string(),
   removed: zodOpenapi.z.boolean()
-});
+}).openapi("RemovedResponse");
 var ProjectSelectSchema = drizzleZod.createSelectSchema(projects);
 var ProjectInsertSchema = drizzleZod.createInsertSchema(projects).extend({
   models: ProjectModelSchema,
@@ -1553,15 +1565,19 @@ var ProjectInsertSchema = drizzleZod.createInsertSchema(projects).extend({
   updatedAt: true
 });
 var ProjectUpdateSchema = ProjectInsertSchema.partial();
-var ProjectApiSelectSchema = ProjectSelectSchema.omit({ tenantId: true });
-var ProjectApiInsertSchema = ProjectInsertSchema.omit({ tenantId: true });
-var ProjectApiUpdateSchema = ProjectUpdateSchema.omit({ tenantId: true });
+var ProjectApiSelectSchema = ProjectSelectSchema.omit({ tenantId: true }).openapi(
+  "Project"
+);
+var ProjectApiInsertSchema = ProjectInsertSchema.omit({ tenantId: true }).openapi(
+  "ProjectCreate"
+);
+var ProjectApiUpdateSchema = ProjectUpdateSchema.omit({ tenantId: true }).openapi(
+  "ProjectUpdate"
+);
 var FullProjectDefinitionSchema = ProjectApiInsertSchema.extend({
-  graphs: zodOpenapi.z.record(zodOpenapi.z.string(), GraphWithinContextOfProjectSchema),
+  agents: zodOpenapi.z.record(zodOpenapi.z.string(), AgentWithinContextOfProjectSchema),
   tools: zodOpenapi.z.record(zodOpenapi.z.string(), ToolApiInsertSchema),
-  // MCP tools (project-scoped)
   functions: zodOpenapi.z.record(zodOpenapi.z.string(), FunctionApiInsertSchema).optional(),
-  // Functions (project-scoped)
   dataComponents: zodOpenapi.z.record(zodOpenapi.z.string(), DataComponentApiInsertSchema).optional(),
   artifactComponents: zodOpenapi.z.record(zodOpenapi.z.string(), ArtifactComponentApiInsertSchema).optional(),
   statusUpdates: zodOpenapi.z.optional(StatusUpdateSchema),
@@ -1569,6 +1585,96 @@ var FullProjectDefinitionSchema = ProjectApiInsertSchema.extend({
   createdAt: zodOpenapi.z.string().optional(),
   updatedAt: zodOpenapi.z.string().optional()
 });
+var ProjectResponse = zodOpenapi.z.object({ data: ProjectApiSelectSchema }).openapi("ProjectResponse");
+var SubAgentResponse = zodOpenapi.z.object({ data: SubAgentApiSelectSchema }).openapi("SubAgentResponse");
+var AgentResponse = zodOpenapi.z.object({ data: AgentApiSelectSchema }).openapi("AgentResponse");
+var ToolResponse = zodOpenapi.z.object({ data: ToolApiSelectSchema }).openapi("ToolResponse");
+var ExternalAgentResponse = zodOpenapi.z.object({ data: ExternalAgentApiSelectSchema }).openapi("ExternalAgentResponse");
+var ContextConfigResponse = zodOpenapi.z.object({ data: ContextConfigApiSelectSchema }).openapi("ContextConfigResponse");
+var ApiKeyResponse = zodOpenapi.z.object({ data: ApiKeyApiSelectSchema }).openapi("ApiKeyResponse");
+var CredentialReferenceResponse = zodOpenapi.z.object({ data: CredentialReferenceApiSelectSchema }).openapi("CredentialReferenceResponse");
+var FunctionResponse = zodOpenapi.z.object({ data: FunctionApiSelectSchema }).openapi("FunctionResponse");
+var FunctionToolResponse = zodOpenapi.z.object({ data: FunctionToolApiSelectSchema }).openapi("FunctionToolResponse");
+var DataComponentResponse = zodOpenapi.z.object({ data: DataComponentApiSelectSchema }).openapi("DataComponentResponse");
+var ArtifactComponentResponse = zodOpenapi.z.object({ data: ArtifactComponentApiSelectSchema }).openapi("ArtifactComponentResponse");
+var SubAgentRelationResponse = zodOpenapi.z.object({ data: SubAgentRelationApiSelectSchema }).openapi("SubAgentRelationResponse");
+var SubAgentToolRelationResponse = zodOpenapi.z.object({ data: SubAgentToolRelationApiSelectSchema }).openapi("SubAgentToolRelationResponse");
+var ConversationResponse = zodOpenapi.z.object({ data: ConversationApiSelectSchema }).openapi("ConversationResponse");
+var MessageResponse = zodOpenapi.z.object({ data: MessageApiSelectSchema }).openapi("MessageResponse");
+var ProjectListResponse = zodOpenapi.z.object({
+  data: zodOpenapi.z.array(ProjectApiSelectSchema),
+  pagination: PaginationSchema
+}).openapi("ProjectListResponse");
+var SubAgentListResponse = zodOpenapi.z.object({
+  data: zodOpenapi.z.array(SubAgentApiSelectSchema),
+  pagination: PaginationSchema
+}).openapi("SubAgentListResponse");
+var AgentListResponse = zodOpenapi.z.object({
+  data: zodOpenapi.z.array(AgentApiSelectSchema),
+  pagination: PaginationSchema
+}).openapi("AgentListResponse");
+var ToolListResponse = zodOpenapi.z.object({
+  data: zodOpenapi.z.array(ToolApiSelectSchema),
+  pagination: PaginationSchema
+}).openapi("ToolListResponse");
+var ExternalAgentListResponse = zodOpenapi.z.object({
+  data: zodOpenapi.z.array(ExternalAgentApiSelectSchema),
+  pagination: PaginationSchema
+}).openapi("ExternalAgentListResponse");
+var ContextConfigListResponse = zodOpenapi.z.object({
+  data: zodOpenapi.z.array(ContextConfigApiSelectSchema),
+  pagination: PaginationSchema
+}).openapi("ContextConfigListResponse");
+var ApiKeyListResponse = zodOpenapi.z.object({
+  data: zodOpenapi.z.array(ApiKeyApiSelectSchema),
+  pagination: PaginationSchema
+}).openapi("ApiKeyListResponse");
+var CredentialReferenceListResponse = zodOpenapi.z.object({
+  data: zodOpenapi.z.array(CredentialReferenceApiSelectSchema),
+  pagination: PaginationSchema
+}).openapi("CredentialReferenceListResponse");
+var FunctionListResponse = zodOpenapi.z.object({
+  data: zodOpenapi.z.array(FunctionApiSelectSchema),
+  pagination: PaginationSchema
+}).openapi("FunctionListResponse");
+var FunctionToolListResponse = zodOpenapi.z.object({
+  data: zodOpenapi.z.array(FunctionToolApiSelectSchema),
+  pagination: PaginationSchema
+}).openapi("FunctionToolListResponse");
+var DataComponentListResponse = zodOpenapi.z.object({
+  data: zodOpenapi.z.array(DataComponentApiSelectSchema),
+  pagination: PaginationSchema
+}).openapi("DataComponentListResponse");
+var ArtifactComponentListResponse = zodOpenapi.z.object({
+  data: zodOpenapi.z.array(ArtifactComponentApiSelectSchema),
+  pagination: PaginationSchema
+}).openapi("ArtifactComponentListResponse");
+var SubAgentRelationListResponse = zodOpenapi.z.object({
+  data: zodOpenapi.z.array(SubAgentRelationApiSelectSchema),
+  pagination: PaginationSchema
+}).openapi("SubAgentRelationListResponse");
+var SubAgentToolRelationListResponse = zodOpenapi.z.object({
+  data: zodOpenapi.z.array(SubAgentToolRelationApiSelectSchema),
+  pagination: PaginationSchema
+}).openapi("SubAgentToolRelationListResponse");
+var ConversationListResponse = zodOpenapi.z.object({
+  data: zodOpenapi.z.array(ConversationApiSelectSchema),
+  pagination: PaginationSchema
+}).openapi("ConversationListResponse");
+var MessageListResponse = zodOpenapi.z.object({
+  data: zodOpenapi.z.array(MessageApiSelectSchema),
+  pagination: PaginationSchema
+}).openapi("MessageListResponse");
+var SubAgentDataComponentResponse = zodOpenapi.z.object({ data: SubAgentDataComponentApiSelectSchema }).openapi("SubAgentDataComponentResponse");
+var SubAgentArtifactComponentResponse = zodOpenapi.z.object({ data: SubAgentArtifactComponentApiSelectSchema }).openapi("SubAgentArtifactComponentResponse");
+var SubAgentDataComponentListResponse = zodOpenapi.z.object({
+  data: zodOpenapi.z.array(SubAgentDataComponentApiSelectSchema),
+  pagination: PaginationSchema
+}).openapi("SubAgentDataComponentListResponse");
+var SubAgentArtifactComponentListResponse = zodOpenapi.z.object({
+  data: zodOpenapi.z.array(SubAgentArtifactComponentApiSelectSchema),
+  pagination: PaginationSchema
+}).openapi("SubAgentArtifactComponentListResponse");
 var HeadersScopeSchema = zodOpenapi.z.object({
   "x-inkeep-tenant-id": zodOpenapi.z.string().optional().openapi({
     description: "Tenant identifier",
@@ -1578,9 +1684,9 @@ var HeadersScopeSchema = zodOpenapi.z.object({
     description: "Project identifier",
     example: "project_456"
   }),
-  "x-inkeep-graph-id": zodOpenapi.z.string().optional().openapi({
-    description: "Graph identifier",
-    example: "graph_789"
+  "x-inkeep-agent-id": zodOpenapi.z.string().optional().openapi({
+    description: "Agent identifier",
+    example: "agent_789"
   })
 });
 var TenantId = zodOpenapi.z.string().openapi({
@@ -1591,9 +1697,9 @@ var ProjectId = zodOpenapi.z.string().openapi({
   description: "Project identifier",
   example: "project_456"
 });
-var GraphId = zodOpenapi.z.string().openapi({
-  description: "Graph identifier",
-  example: "graph_789"
+var AgentId = zodOpenapi.z.string().openapi({
+  description: "Agent identifier",
+  example: "agent_789"
 });
 var SubAgentId = zodOpenapi.z.string().openapi({
   description: "Sub-agent identifier",
@@ -1611,41 +1717,41 @@ var TenantProjectParamsSchema = TenantParamsSchema.extend({
 var TenantProjectIdParamsSchema = TenantProjectParamsSchema.extend({
   id: resourceIdSchema
 }).openapi("TenantProjectIdParams");
-var TenantProjectGraphParamsSchema = TenantProjectParamsSchema.extend({
-  graphId: GraphId
-}).openapi("TenantProjectGraphParams");
-var TenantProjectGraphIdParamsSchema = TenantProjectGraphParamsSchema.extend({
+var TenantProjectAgentParamsSchema = TenantProjectParamsSchema.extend({
+  agentId: AgentId
+}).openapi("TenantProjectAgentParams");
+var TenantProjectAgentIdParamsSchema = TenantProjectAgentParamsSchema.extend({
   id: resourceIdSchema
-}).openapi("TenantProjectGraphIdParams");
-var TenantProjectGraphSubAgentParamsSchema = TenantProjectGraphParamsSchema.extend({
+}).openapi("TenantProjectAgentIdParams");
+var TenantProjectAgentSubAgentParamsSchema = TenantProjectAgentParamsSchema.extend({
   subAgentId: SubAgentId
-}).openapi("TenantProjectGraphSubAgentParams");
-var TenantProjectGraphSubAgentIdParamsSchema = TenantProjectGraphSubAgentParamsSchema.extend({
+}).openapi("TenantProjectAgentSubAgentParams");
+var TenantProjectAgentSubAgentIdParamsSchema = TenantProjectAgentSubAgentParamsSchema.extend({
   id: resourceIdSchema
-}).openapi("TenantProjectGraphSubAgentIdParams");
+}).openapi("TenantProjectAgentSubAgentIdParams");
 var PaginationQueryParamsSchema = zodOpenapi.z.object({
   page: zodOpenapi.z.coerce.number().min(1).default(1),
   limit: zodOpenapi.z.coerce.number().min(1).max(100).default(10)
 });
 
-// src/validation/graphFull.ts
+// src/validation/agentFull.ts
 function isInternalAgent(agent) {
   return "prompt" in agent;
 }
 function isExternalAgent(agent) {
   return "baseUrl" in agent;
 }
-function validateAndTypeGraphData(data) {
-  return GraphWithinContextOfProjectSchema.parse(data);
+function validateAndTypeAgentData(data) {
+  return AgentWithinContextOfProjectSchema.parse(data);
 }
-function validateToolReferences(graphData, availableToolIds) {
+function validateToolReferences(agentData, availableToolIds) {
   if (!availableToolIds) {
     return;
   }
   const errors = [];
-  for (const [subAgentId, agentData] of Object.entries(graphData.subAgents)) {
-    if (isInternalAgent(agentData) && agentData.canUse && Array.isArray(agentData.canUse)) {
-      for (const canUseItem of agentData.canUse) {
+  for (const [subAgentId, subAgent] of Object.entries(agentData.subAgents)) {
+    if (isInternalAgent(subAgent) && subAgent.canUse && Array.isArray(subAgent.canUse)) {
+      for (const canUseItem of subAgent.canUse) {
         if (!availableToolIds.has(canUseItem.toolId)) {
           errors.push(`Agent '${subAgentId}' references non-existent tool '${canUseItem.toolId}'`);
         }
@@ -1657,14 +1763,14 @@ function validateToolReferences(graphData, availableToolIds) {
 ${errors.join("\n")}`);
   }
 }
-function validateDataComponentReferences(graphData, availableDataComponentIds) {
+function validateDataComponentReferences(agentData, availableDataComponentIds) {
   if (!availableDataComponentIds) {
     return;
   }
   const errors = [];
-  for (const [subAgentId, agentData] of Object.entries(graphData.subAgents)) {
-    if (isInternalAgent(agentData) && agentData.dataComponents) {
-      for (const dataComponentId of agentData.dataComponents) {
+  for (const [subAgentId, subAgent] of Object.entries(agentData.subAgents)) {
+    if (isInternalAgent(subAgent) && subAgent.dataComponents) {
+      for (const dataComponentId of subAgent.dataComponents) {
         if (!availableDataComponentIds.has(dataComponentId)) {
           errors.push(
             `Agent '${subAgentId}' references non-existent dataComponent '${dataComponentId}'`
@@ -1678,14 +1784,14 @@ function validateDataComponentReferences(graphData, availableDataComponentIds) {
 ${errors.join("\n")}`);
   }
 }
-function validateArtifactComponentReferences(graphData, availableArtifactComponentIds) {
+function validateArtifactComponentReferences(agentData, availableArtifactComponentIds) {
   if (!availableArtifactComponentIds) {
     return;
   }
   const errors = [];
-  for (const [subAgentId, agentData] of Object.entries(graphData.subAgents)) {
-    if (isInternalAgent(agentData) && agentData.artifactComponents) {
-      for (const artifactComponentId of agentData.artifactComponents) {
+  for (const [subAgentId, subAgent] of Object.entries(agentData.subAgents)) {
+    if (isInternalAgent(subAgent) && subAgent.artifactComponents) {
+      for (const artifactComponentId of subAgent.artifactComponents) {
         if (!availableArtifactComponentIds.has(artifactComponentId)) {
           errors.push(
             `Agent '${subAgentId}' references non-existent artifactComponent '${artifactComponentId}'`
@@ -1699,25 +1805,25 @@ function validateArtifactComponentReferences(graphData, availableArtifactCompone
 ${errors.join("\n")}`);
   }
 }
-function validateAgentRelationships(graphData) {
+function validateAgentRelationships(agentData) {
   const errors = [];
-  const availableAgentIds = new Set(Object.keys(graphData.subAgents));
-  for (const [subAgentId, agentData] of Object.entries(graphData.subAgents)) {
-    if (isInternalAgent(agentData)) {
-      if (agentData.canTransferTo && Array.isArray(agentData.canTransferTo)) {
-        for (const targetId of agentData.canTransferTo) {
+  const availableAgentIds = new Set(Object.keys(agentData.subAgents));
+  for (const [subAgentId, subAgent] of Object.entries(agentData.subAgents)) {
+    if (isInternalAgent(subAgent)) {
+      if (subAgent.canTransferTo && Array.isArray(subAgent.canTransferTo)) {
+        for (const targetId of subAgent.canTransferTo) {
           if (!availableAgentIds.has(targetId)) {
             errors.push(
-              `Agent '${subAgentId}' has transfer target '${targetId}' that doesn't exist in graph`
+              `Agent '${subAgentId}' has transfer target '${targetId}' that doesn't exist in agent`
             );
           }
         }
       }
-      if (agentData.canDelegateTo && Array.isArray(agentData.canDelegateTo)) {
-        for (const targetId of agentData.canDelegateTo) {
+      if (subAgent.canDelegateTo && Array.isArray(subAgent.canDelegateTo)) {
+        for (const targetId of subAgent.canDelegateTo) {
           if (!availableAgentIds.has(targetId)) {
             errors.push(
-              `Agent '${subAgentId}' has delegation target '${targetId}' that doesn't exist in graph`
+              `Agent '${subAgentId}' has delegation target '${targetId}' that doesn't exist in agent`
             );
           }
         }
@@ -1729,16 +1835,16 @@ function validateAgentRelationships(graphData) {
 ${errors.join("\n")}`);
   }
 }
-function validateGraphStructure(graphData, projectResources) {
-  if (graphData.defaultSubAgentId && !graphData.subAgents[graphData.defaultSubAgentId]) {
-    throw new Error(`Default agent '${graphData.defaultSubAgentId}' does not exist in agents`);
+function validateAgentStructure(agentData, projectResources) {
+  if (agentData.defaultSubAgentId && !agentData.subAgents[agentData.defaultSubAgentId]) {
+    throw new Error(`Default agent '${agentData.defaultSubAgentId}' does not exist in agents`);
   }
   if (projectResources) {
-    validateToolReferences(graphData, projectResources.toolIds);
-    validateDataComponentReferences(graphData, projectResources.dataComponentIds);
-    validateArtifactComponentReferences(graphData, projectResources.artifactComponentIds);
+    validateToolReferences(agentData, projectResources.toolIds);
+    validateDataComponentReferences(agentData, projectResources.dataComponentIds);
+    validateArtifactComponentReferences(agentData, projectResources.artifactComponentIds);
   }
-  validateAgentRelationships(graphData);
+  validateAgentRelationships(agentData);
 }
 
 // src/validation/id-validation.ts
@@ -1862,24 +1968,32 @@ function validatePropsAsJsonSchema(props) {
 }
 
 exports.A2AMessageMetadataSchema = A2AMessageMetadataSchema;
-exports.AgentGraphApiInsertSchema = AgentGraphApiInsertSchema;
-exports.AgentGraphApiSelectSchema = AgentGraphApiSelectSchema;
-exports.AgentGraphApiUpdateSchema = AgentGraphApiUpdateSchema;
-exports.AgentGraphInsertSchema = AgentGraphInsertSchema;
-exports.AgentGraphSelectSchema = AgentGraphSelectSchema;
-exports.AgentGraphUpdateSchema = AgentGraphUpdateSchema;
+exports.AgentApiInsertSchema = AgentApiInsertSchema;
+exports.AgentApiSelectSchema = AgentApiSelectSchema;
+exports.AgentApiUpdateSchema = AgentApiUpdateSchema;
+exports.AgentInsertSchema = AgentInsertSchema;
+exports.AgentListResponse = AgentListResponse;
+exports.AgentResponse = AgentResponse;
+exports.AgentSelectSchema = AgentSelectSchema;
+exports.AgentStopWhenSchema = AgentStopWhenSchema;
+exports.AgentUpdateSchema = AgentUpdateSchema;
+exports.AgentWithinContextOfProjectSchema = AgentWithinContextOfProjectSchema;
 exports.AllAgentSchema = AllAgentSchema;
 exports.ApiKeyApiCreationResponseSchema = ApiKeyApiCreationResponseSchema;
 exports.ApiKeyApiInsertSchema = ApiKeyApiInsertSchema;
 exports.ApiKeyApiSelectSchema = ApiKeyApiSelectSchema;
 exports.ApiKeyApiUpdateSchema = ApiKeyApiUpdateSchema;
 exports.ApiKeyInsertSchema = ApiKeyInsertSchema;
+exports.ApiKeyListResponse = ApiKeyListResponse;
+exports.ApiKeyResponse = ApiKeyResponse;
 exports.ApiKeySelectSchema = ApiKeySelectSchema;
 exports.ApiKeyUpdateSchema = ApiKeyUpdateSchema;
 exports.ArtifactComponentApiInsertSchema = ArtifactComponentApiInsertSchema;
 exports.ArtifactComponentApiSelectSchema = ArtifactComponentApiSelectSchema;
 exports.ArtifactComponentApiUpdateSchema = ArtifactComponentApiUpdateSchema;
 exports.ArtifactComponentInsertSchema = ArtifactComponentInsertSchema;
+exports.ArtifactComponentListResponse = ArtifactComponentListResponse;
+exports.ArtifactComponentResponse = ArtifactComponentResponse;
 exports.ArtifactComponentSelectSchema = ArtifactComponentSelectSchema;
 exports.ArtifactComponentUpdateSchema = ArtifactComponentUpdateSchema;
 exports.CanUseItemSchema = CanUseItemSchema;
@@ -1893,18 +2007,24 @@ exports.ContextConfigApiInsertSchema = ContextConfigApiInsertSchema;
 exports.ContextConfigApiSelectSchema = ContextConfigApiSelectSchema;
 exports.ContextConfigApiUpdateSchema = ContextConfigApiUpdateSchema;
 exports.ContextConfigInsertSchema = ContextConfigInsertSchema;
+exports.ContextConfigListResponse = ContextConfigListResponse;
+exports.ContextConfigResponse = ContextConfigResponse;
 exports.ContextConfigSelectSchema = ContextConfigSelectSchema;
 exports.ContextConfigUpdateSchema = ContextConfigUpdateSchema;
 exports.ConversationApiInsertSchema = ConversationApiInsertSchema;
 exports.ConversationApiSelectSchema = ConversationApiSelectSchema;
 exports.ConversationApiUpdateSchema = ConversationApiUpdateSchema;
 exports.ConversationInsertSchema = ConversationInsertSchema;
+exports.ConversationListResponse = ConversationListResponse;
+exports.ConversationResponse = ConversationResponse;
 exports.ConversationSelectSchema = ConversationSelectSchema;
 exports.ConversationUpdateSchema = ConversationUpdateSchema;
 exports.CredentialReferenceApiInsertSchema = CredentialReferenceApiInsertSchema;
 exports.CredentialReferenceApiSelectSchema = CredentialReferenceApiSelectSchema;
 exports.CredentialReferenceApiUpdateSchema = CredentialReferenceApiUpdateSchema;
 exports.CredentialReferenceInsertSchema = CredentialReferenceInsertSchema;
+exports.CredentialReferenceListResponse = CredentialReferenceListResponse;
+exports.CredentialReferenceResponse = CredentialReferenceResponse;
 exports.CredentialReferenceSelectSchema = CredentialReferenceSelectSchema;
 exports.CredentialReferenceUpdateSchema = CredentialReferenceUpdateSchema;
 exports.DataComponentApiInsertSchema = DataComponentApiInsertSchema;
@@ -1912,6 +2032,8 @@ exports.DataComponentApiSelectSchema = DataComponentApiSelectSchema;
 exports.DataComponentApiUpdateSchema = DataComponentApiUpdateSchema;
 exports.DataComponentBaseSchema = DataComponentBaseSchema;
 exports.DataComponentInsertSchema = DataComponentInsertSchema;
+exports.DataComponentListResponse = DataComponentListResponse;
+exports.DataComponentResponse = DataComponentResponse;
 exports.DataComponentSelectSchema = DataComponentSelectSchema;
 exports.DataComponentUpdateSchema = DataComponentUpdateSchema;
 exports.DataOperationDetailsSchema = DataOperationDetailsSchema;
@@ -1924,30 +2046,33 @@ exports.ExternalAgentApiInsertSchema = ExternalAgentApiInsertSchema;
 exports.ExternalAgentApiSelectSchema = ExternalAgentApiSelectSchema;
 exports.ExternalAgentApiUpdateSchema = ExternalAgentApiUpdateSchema;
 exports.ExternalAgentInsertSchema = ExternalAgentInsertSchema;
+exports.ExternalAgentListResponse = ExternalAgentListResponse;
+exports.ExternalAgentResponse = ExternalAgentResponse;
 exports.ExternalAgentSelectSchema = ExternalAgentSelectSchema;
 exports.ExternalAgentUpdateSchema = ExternalAgentUpdateSchema;
 exports.ExternalSubAgentRelationApiInsertSchema = ExternalSubAgentRelationApiInsertSchema;
 exports.ExternalSubAgentRelationInsertSchema = ExternalSubAgentRelationInsertSchema;
 exports.FetchConfigSchema = FetchConfigSchema;
 exports.FetchDefinitionSchema = FetchDefinitionSchema;
-exports.FullGraphAgentInsertSchema = FullGraphAgentInsertSchema;
-exports.FullGraphDefinitionSchema = FullGraphDefinitionSchema;
+exports.FullAgentAgentInsertSchema = FullAgentAgentInsertSchema;
 exports.FullProjectDefinitionSchema = FullProjectDefinitionSchema;
 exports.FunctionApiInsertSchema = FunctionApiInsertSchema;
 exports.FunctionApiSelectSchema = FunctionApiSelectSchema;
 exports.FunctionApiUpdateSchema = FunctionApiUpdateSchema;
 exports.FunctionInsertSchema = FunctionInsertSchema;
+exports.FunctionListResponse = FunctionListResponse;
+exports.FunctionResponse = FunctionResponse;
 exports.FunctionSelectSchema = FunctionSelectSchema;
 exports.FunctionToolApiInsertSchema = FunctionToolApiInsertSchema;
 exports.FunctionToolApiSelectSchema = FunctionToolApiSelectSchema;
 exports.FunctionToolApiUpdateSchema = FunctionToolApiUpdateSchema;
 exports.FunctionToolConfigSchema = FunctionToolConfigSchema;
 exports.FunctionToolInsertSchema = FunctionToolInsertSchema;
+exports.FunctionToolListResponse = FunctionToolListResponse;
+exports.FunctionToolResponse = FunctionToolResponse;
 exports.FunctionToolSelectSchema = FunctionToolSelectSchema;
 exports.FunctionToolUpdateSchema = FunctionToolUpdateSchema;
 exports.FunctionUpdateSchema = FunctionUpdateSchema;
-exports.GraphStopWhenSchema = GraphStopWhenSchema;
-exports.GraphWithinContextOfProjectSchema = GraphWithinContextOfProjectSchema;
 exports.HeadersScopeSchema = HeadersScopeSchema;
 exports.LedgerArtifactApiInsertSchema = LedgerArtifactApiInsertSchema;
 exports.LedgerArtifactApiSelectSchema = LedgerArtifactApiSelectSchema;
@@ -1966,6 +2091,8 @@ exports.MessageApiInsertSchema = MessageApiInsertSchema;
 exports.MessageApiSelectSchema = MessageApiSelectSchema;
 exports.MessageApiUpdateSchema = MessageApiUpdateSchema;
 exports.MessageInsertSchema = MessageInsertSchema;
+exports.MessageListResponse = MessageListResponse;
+exports.MessageResponse = MessageResponse;
 exports.MessageSelectSchema = MessageSelectSchema;
 exports.MessageUpdateSchema = MessageUpdateSchema;
 exports.ModelSchema = ModelSchema;
@@ -1976,7 +2103,9 @@ exports.ProjectApiInsertSchema = ProjectApiInsertSchema;
 exports.ProjectApiSelectSchema = ProjectApiSelectSchema;
 exports.ProjectApiUpdateSchema = ProjectApiUpdateSchema;
 exports.ProjectInsertSchema = ProjectInsertSchema;
+exports.ProjectListResponse = ProjectListResponse;
 exports.ProjectModelSchema = ProjectModelSchema;
+exports.ProjectResponse = ProjectResponse;
 exports.ProjectSelectSchema = ProjectSelectSchema;
 exports.ProjectUpdateSchema = ProjectUpdateSchema;
 exports.RemovedResponseSchema = RemovedResponseSchema;
@@ -1992,28 +2121,38 @@ exports.SubAgentArtifactComponentApiInsertSchema = SubAgentArtifactComponentApiI
 exports.SubAgentArtifactComponentApiSelectSchema = SubAgentArtifactComponentApiSelectSchema;
 exports.SubAgentArtifactComponentApiUpdateSchema = SubAgentArtifactComponentApiUpdateSchema;
 exports.SubAgentArtifactComponentInsertSchema = SubAgentArtifactComponentInsertSchema;
+exports.SubAgentArtifactComponentListResponse = SubAgentArtifactComponentListResponse;
+exports.SubAgentArtifactComponentResponse = SubAgentArtifactComponentResponse;
 exports.SubAgentArtifactComponentSelectSchema = SubAgentArtifactComponentSelectSchema;
 exports.SubAgentArtifactComponentUpdateSchema = SubAgentArtifactComponentUpdateSchema;
 exports.SubAgentDataComponentApiInsertSchema = SubAgentDataComponentApiInsertSchema;
 exports.SubAgentDataComponentApiSelectSchema = SubAgentDataComponentApiSelectSchema;
 exports.SubAgentDataComponentApiUpdateSchema = SubAgentDataComponentApiUpdateSchema;
 exports.SubAgentDataComponentInsertSchema = SubAgentDataComponentInsertSchema;
+exports.SubAgentDataComponentListResponse = SubAgentDataComponentListResponse;
+exports.SubAgentDataComponentResponse = SubAgentDataComponentResponse;
 exports.SubAgentDataComponentSelectSchema = SubAgentDataComponentSelectSchema;
 exports.SubAgentDataComponentUpdateSchema = SubAgentDataComponentUpdateSchema;
 exports.SubAgentInsertSchema = SubAgentInsertSchema;
+exports.SubAgentListResponse = SubAgentListResponse;
 exports.SubAgentRelationApiInsertSchema = SubAgentRelationApiInsertSchema;
 exports.SubAgentRelationApiSelectSchema = SubAgentRelationApiSelectSchema;
 exports.SubAgentRelationApiUpdateSchema = SubAgentRelationApiUpdateSchema;
 exports.SubAgentRelationInsertSchema = SubAgentRelationInsertSchema;
+exports.SubAgentRelationListResponse = SubAgentRelationListResponse;
 exports.SubAgentRelationQuerySchema = SubAgentRelationQuerySchema;
+exports.SubAgentRelationResponse = SubAgentRelationResponse;
 exports.SubAgentRelationSelectSchema = SubAgentRelationSelectSchema;
 exports.SubAgentRelationUpdateSchema = SubAgentRelationUpdateSchema;
+exports.SubAgentResponse = SubAgentResponse;
 exports.SubAgentSelectSchema = SubAgentSelectSchema;
 exports.SubAgentStopWhenSchema = SubAgentStopWhenSchema;
 exports.SubAgentToolRelationApiInsertSchema = SubAgentToolRelationApiInsertSchema;
 exports.SubAgentToolRelationApiSelectSchema = SubAgentToolRelationApiSelectSchema;
 exports.SubAgentToolRelationApiUpdateSchema = SubAgentToolRelationApiUpdateSchema;
 exports.SubAgentToolRelationInsertSchema = SubAgentToolRelationInsertSchema;
+exports.SubAgentToolRelationListResponse = SubAgentToolRelationListResponse;
+exports.SubAgentToolRelationResponse = SubAgentToolRelationResponse;
 exports.SubAgentToolRelationSelectSchema = SubAgentToolRelationSelectSchema;
 exports.SubAgentToolRelationUpdateSchema = SubAgentToolRelationUpdateSchema;
 exports.SubAgentUpdateSchema = SubAgentUpdateSchema;
@@ -2031,16 +2170,18 @@ exports.TaskSelectSchema = TaskSelectSchema;
 exports.TaskUpdateSchema = TaskUpdateSchema;
 exports.TenantIdParamsSchema = TenantIdParamsSchema;
 exports.TenantParamsSchema = TenantParamsSchema;
-exports.TenantProjectGraphIdParamsSchema = TenantProjectGraphIdParamsSchema;
-exports.TenantProjectGraphParamsSchema = TenantProjectGraphParamsSchema;
-exports.TenantProjectGraphSubAgentIdParamsSchema = TenantProjectGraphSubAgentIdParamsSchema;
-exports.TenantProjectGraphSubAgentParamsSchema = TenantProjectGraphSubAgentParamsSchema;
+exports.TenantProjectAgentIdParamsSchema = TenantProjectAgentIdParamsSchema;
+exports.TenantProjectAgentParamsSchema = TenantProjectAgentParamsSchema;
+exports.TenantProjectAgentSubAgentIdParamsSchema = TenantProjectAgentSubAgentIdParamsSchema;
+exports.TenantProjectAgentSubAgentParamsSchema = TenantProjectAgentSubAgentParamsSchema;
 exports.TenantProjectIdParamsSchema = TenantProjectIdParamsSchema;
 exports.TenantProjectParamsSchema = TenantProjectParamsSchema;
 exports.ToolApiInsertSchema = ToolApiInsertSchema;
 exports.ToolApiSelectSchema = ToolApiSelectSchema;
 exports.ToolApiUpdateSchema = ToolApiUpdateSchema;
 exports.ToolInsertSchema = ToolInsertSchema;
+exports.ToolListResponse = ToolListResponse;
+exports.ToolResponse = ToolResponse;
 exports.ToolSelectSchema = ToolSelectSchema;
 exports.ToolStatusSchema = ToolStatusSchema;
 exports.ToolUpdateSchema = ToolUpdateSchema;
@@ -2052,9 +2193,9 @@ exports.isInternalAgent = isInternalAgent;
 exports.isValidResourceId = isValidResourceId;
 exports.resourceIdSchema = resourceIdSchema;
 exports.validateAgentRelationships = validateAgentRelationships;
-exports.validateAndTypeGraphData = validateAndTypeGraphData;
+exports.validateAgentStructure = validateAgentStructure;
+exports.validateAndTypeAgentData = validateAndTypeAgentData;
 exports.validateArtifactComponentReferences = validateArtifactComponentReferences;
 exports.validateDataComponentReferences = validateDataComponentReferences;
-exports.validateGraphStructure = validateGraphStructure;
 exports.validatePropsAsJsonSchema = validatePropsAsJsonSchema;
 exports.validateToolReferences = validateToolReferences;