@inkeep/agents-core 0.17.0 → 0.18.1

package/dist/client-exports.cjs

@@ -41,9 +41,9 @@ var graphScoped = {
   ...projectScoped,
   graphId: sqliteCore.text("graph_id").notNull()
 };
-var agentScoped = {
+var subAgentScoped = {
   ...graphScoped,
-  agentId: sqliteCore.text("agent_id").notNull()
+  subAgentId: sqliteCore.text("sub_agent_id").notNull()
 };
 var uiProperties = {
   name: sqliteCore.text("name").notNull(),
@@ -74,7 +74,7 @@ var agentGraph = sqliteCore.sqliteTable(
     ...projectScoped,
     name: sqliteCore.text("name").notNull(),
     description: sqliteCore.text("description"),
-    defaultAgentId: sqliteCore.text("default_agent_id"),
+    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
@@ -153,8 +153,8 @@ var contextCache = sqliteCore.sqliteTable(
     )
   ]
 );
-var agents = sqliteCore.sqliteTable(
-  "agents",
+var subAgents = sqliteCore.sqliteTable(
+  "sub_agents",
   {
     ...graphScoped,
     ...uiProperties,
@@ -176,17 +176,16 @@ var agents = sqliteCore.sqliteTable(
     }).onDelete("cascade")
   ]
 );
-var agentRelations = sqliteCore.sqliteTable(
-  "agent_relations",
+var subAgentRelations = sqliteCore.sqliteTable(
+  "sub_agent_relations",
   {
     ...graphScoped,
-    sourceAgentId: sqliteCore.text("source_agent_id").notNull(),
+    sourceSubAgentId: sqliteCore.text("source_sub_agent_id").notNull(),
     // For internal relationships
-    targetAgentId: sqliteCore.text("target_agent_id"),
+    targetSubAgentId: sqliteCore.text("target_sub_agent_id"),
     // For external relationships
-    externalAgentId: sqliteCore.text("external_agent_id"),
+    externalSubAgentId: sqliteCore.text("external_sub_agent_id"),
     relationType: sqliteCore.text("relation_type"),
-    // 'transfer' | 'delegate'
     ...timestamps
   },
   (table) => [
@@ -194,7 +193,7 @@ var agentRelations = sqliteCore.sqliteTable(
     sqliteCore.foreignKey({
       columns: [table.tenantId, table.projectId, table.graphId],
       foreignColumns: [agentGraph.tenantId, agentGraph.projectId, agentGraph.id],
-      name: "agent_relations_graph_fk"
+      name: "sub_agent_relations_graph_fk"
     }).onDelete("cascade")
   ]
 );
@@ -230,7 +229,7 @@ var externalAgents = sqliteCore.sqliteTable(
 var tasks = sqliteCore.sqliteTable(
   "tasks",
   {
-    ...agentScoped,
+    ...subAgentScoped,
     contextId: sqliteCore.text("context_id").notNull(),
     status: sqliteCore.text("status").notNull(),
     metadata: sqliteCore.blob("metadata", { mode: "json" }).$type(),
@@ -239,9 +238,9 @@ var tasks = sqliteCore.sqliteTable(
   (table) => [
     sqliteCore.primaryKey({ columns: [table.tenantId, table.projectId, table.id] }),
     sqliteCore.foreignKey({
-      columns: [table.tenantId, table.projectId, table.graphId, table.agentId],
-      foreignColumns: [agents.tenantId, agents.projectId, agents.graphId, agents.id],
-      name: "tasks_agent_fk"
+      columns: [table.tenantId, table.projectId, table.graphId, table.subAgentId],
+      foreignColumns: [subAgents.tenantId, subAgents.projectId, subAgents.graphId, subAgents.id],
+      name: "tasks_sub_agent_fk"
     }).onDelete("cascade")
   ]
 );
@@ -281,10 +280,10 @@ var dataComponents = sqliteCore.sqliteTable(
     }).onDelete("cascade")
   ]
 );
-var agentDataComponents = sqliteCore.sqliteTable(
-  "agent_data_components",
+var subAgentDataComponents = sqliteCore.sqliteTable(
+  "sub_agent_data_components",
   {
-    ...agentScoped,
+    ...subAgentScoped,
     dataComponentId: sqliteCore.text("data_component_id").notNull(),
     createdAt: sqliteCore.text("created_at").notNull().default(drizzleOrm.sql`CURRENT_TIMESTAMP`)
   },
@@ -292,15 +291,15 @@ var agentDataComponents = sqliteCore.sqliteTable(
     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.agentId],
-      foreignColumns: [agents.tenantId, agents.projectId, agents.graphId, agents.id],
-      name: "agent_data_components_agent_fk"
+      columns: [table.tenantId, table.projectId, table.graphId, table.subAgentId],
+      foreignColumns: [subAgents.tenantId, subAgents.projectId, subAgents.graphId, 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],
-      name: "agent_data_components_data_component_fk"
+      name: "sub_agent_data_components_data_component_fk"
     }).onDelete("cascade")
   ]
 );
@@ -321,22 +320,22 @@ var artifactComponents = sqliteCore.sqliteTable(
     }).onDelete("cascade")
   ]
 );
-var agentArtifactComponents = sqliteCore.sqliteTable(
-  "agent_artifact_components",
+var subAgentArtifactComponents = sqliteCore.sqliteTable(
+  "sub_agent_artifact_components",
   {
-    ...agentScoped,
+    ...subAgentScoped,
     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.graphId, table.agentId, table.id]
+      columns: [table.tenantId, table.projectId, table.graphId, 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.agentId],
-      foreignColumns: [agents.tenantId, agents.projectId, agents.graphId, agents.id],
-      name: "agent_artifact_components_agent_fk"
+      columns: [table.tenantId, table.projectId, table.graphId, table.subAgentId],
+      foreignColumns: [subAgents.tenantId, subAgents.projectId, subAgents.graphId, subAgents.id],
+      name: "sub_agent_artifact_components_sub_agent_fk"
     }).onDelete("cascade"),
     // Foreign key constraint to artifact_components table
     sqliteCore.foreignKey({
@@ -346,7 +345,7 @@ var agentArtifactComponents = sqliteCore.sqliteTable(
         artifactComponents.projectId,
         artifactComponents.id
       ],
-      name: "agent_artifact_components_artifact_component_fk"
+      name: "sub_agent_artifact_components_artifact_component_fk"
     }).onDelete("cascade")
   ]
 );
@@ -356,10 +355,7 @@ var tools = sqliteCore.sqliteTable(
     ...projectScoped,
     name: sqliteCore.text("name").notNull(),
     description: sqliteCore.text("description"),
-    // Tool configuration - supports both MCP and function tools
     config: sqliteCore.blob("config", { mode: "json" }).$type().notNull(),
-    // For function tools, reference the global functions table
-    functionId: sqliteCore.text("function_id"),
     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)
@@ -375,12 +371,30 @@ var tools = sqliteCore.sqliteTable(
       columns: [table.tenantId, table.projectId],
       foreignColumns: [projects.tenantId, projects.id],
       name: "tools_project_fk"
+    }).onDelete("cascade")
+  ]
+);
+var functionTools = sqliteCore.sqliteTable(
+  "function_tools",
+  {
+    ...graphScoped,
+    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.foreignKey({
+      columns: [table.tenantId, table.projectId, table.graphId],
+      foreignColumns: [agentGraph.tenantId, agentGraph.projectId, agentGraph.id],
+      name: "function_tools_graph_fk"
     }).onDelete("cascade"),
-    // Foreign key constraint to functions table (for function tools)
+    // Foreign key constraint to functions table
     sqliteCore.foreignKey({
       columns: [table.tenantId, table.projectId, table.functionId],
       foreignColumns: [functions.tenantId, functions.projectId, functions.id],
-      name: "tools_function_fk"
+      name: "function_tools_function_fk"
     }).onDelete("cascade")
   ]
 );
@@ -402,10 +416,10 @@ var functions = sqliteCore.sqliteTable(
     }).onDelete("cascade")
   ]
 );
-var agentToolRelations = sqliteCore.sqliteTable(
-  "agent_tool_relations",
+var subAgentToolRelations = sqliteCore.sqliteTable(
+  "sub_agent_tool_relations",
   {
-    ...agentScoped,
+    ...subAgentScoped,
     toolId: sqliteCore.text("tool_id").notNull(),
     selectedTools: sqliteCore.blob("selected_tools", { mode: "json" }).$type(),
     headers: sqliteCore.blob("headers", { mode: "json" }).$type(),
@@ -415,15 +429,43 @@ var agentToolRelations = sqliteCore.sqliteTable(
     sqliteCore.primaryKey({ columns: [table.tenantId, table.projectId, table.graphId, table.id] }),
     // Foreign key constraint to agents table (which includes project and graph scope)
     sqliteCore.foreignKey({
-      columns: [table.tenantId, table.projectId, table.graphId, table.agentId],
-      foreignColumns: [agents.tenantId, agents.projectId, agents.graphId, agents.id],
-      name: "agent_tool_relations_agent_fk"
+      columns: [table.tenantId, table.projectId, table.graphId, table.subAgentId],
+      foreignColumns: [subAgents.tenantId, subAgents.projectId, subAgents.graphId, subAgents.id],
+      name: "sub_agent_tool_relations_agent_fk"
     }).onDelete("cascade"),
-    // Foreign key constraint to tools table
+    // Foreign key constraint to tools table (MCP tools)
     sqliteCore.foreignKey({
       columns: [table.tenantId, table.projectId, table.toolId],
       foreignColumns: [tools.tenantId, tools.projectId, tools.id],
-      name: "agent_tool_relations_tool_fk"
+      name: "sub_agent_tool_relations_tool_fk"
+    }).onDelete("cascade")
+  ]
+);
+var agentFunctionToolRelations = sqliteCore.sqliteTable(
+  "agent_function_tool_relations",
+  {
+    ...subAgentScoped,
+    functionToolId: sqliteCore.text("function_tool_id").notNull(),
+    ...timestamps
+  },
+  (table) => [
+    sqliteCore.primaryKey({ columns: [table.tenantId, table.projectId, table.graphId, 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],
+      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],
+      foreignColumns: [
+        functionTools.tenantId,
+        functionTools.projectId,
+        functionTools.graphId,
+        functionTools.id
+      ],
+      name: "agent_function_tool_relations_function_tool_fk"
     }).onDelete("cascade")
   ]
 );
@@ -432,7 +474,7 @@ var conversations = sqliteCore.sqliteTable(
   {
     ...projectScoped,
     userId: sqliteCore.text("user_id"),
-    activeAgentId: sqliteCore.text("active_agent_id").notNull(),
+    activeSubAgentId: sqliteCore.text("active_sub_agent_id").notNull(),
     title: sqliteCore.text("title"),
     lastContextResolution: sqliteCore.text("last_context_resolution"),
     metadata: sqliteCore.blob("metadata", { mode: "json" }).$type(),
@@ -456,15 +498,15 @@ var messages = sqliteCore.sqliteTable(
     role: sqliteCore.text("role").notNull(),
     // 'user' | 'agent' | 'system'
     // Agent sender/recipient tracking (nullable - only populated when relevant)
-    fromAgentId: sqliteCore.text("from_agent_id"),
+    fromSubAgentId: sqliteCore.text("from_sub_agent_id"),
     // Populated when message is from an agent
-    toAgentId: sqliteCore.text("to_agent_id"),
+    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_agent_id"),
+    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_agent_id"),
+    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(),
@@ -473,8 +515,6 @@ var messages = sqliteCore.sqliteTable(
     // '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
@@ -601,10 +641,9 @@ drizzleOrm.relations(tasks, ({ one, many }) => ({
   childRelations: many(taskRelations, {
     relationName: "parentTask"
   }),
-  // A task belongs to one agent
-  agent: one(agents, {
-    fields: [tasks.agentId],
-    references: [agents.id]
+  subAgent: one(subAgents, {
+    fields: [tasks.subAgentId],
+    references: [subAgents.id]
   }),
   // A task can have many messages associated with it
   messages: many(messages),
@@ -612,9 +651,10 @@ drizzleOrm.relations(tasks, ({ one, many }) => ({
   ledgerArtifacts: many(ledgerArtifacts)
 }));
 drizzleOrm.relations(projects, ({ many }) => ({
-  agents: many(agents),
+  subAgents: many(subAgents),
   agentGraphs: many(agentGraph),
   tools: many(tools),
+  functions: many(functions),
   contextConfigs: many(contextConfigs),
   externalAgents: many(externalAgents),
   conversations: many(conversations),
@@ -650,17 +690,17 @@ drizzleOrm.relations(contextCache, ({ one }) => ({
     references: [contextConfigs.id]
   })
 }));
-drizzleOrm.relations(agents, ({ many, one }) => ({
+drizzleOrm.relations(subAgents, ({ many, one }) => ({
   project: one(projects, {
-    fields: [agents.tenantId, agents.projectId],
+    fields: [subAgents.tenantId, subAgents.projectId],
     references: [projects.tenantId, projects.id]
   }),
   tasks: many(tasks),
   defaultForGraphs: many(agentGraph),
-  sourceRelations: many(agentRelations, {
+  sourceRelations: many(subAgentRelations, {
     relationName: "sourceRelations"
   }),
-  targetRelations: many(agentRelations, {
+  targetRelations: many(subAgentRelations, {
     relationName: "targetRelations"
   }),
   sentMessages: many(messages, {
@@ -672,30 +712,32 @@ drizzleOrm.relations(agents, ({ many, one }) => ({
   associatedMessages: many(messages, {
     relationName: "associatedAgent"
   }),
-  toolRelations: many(agentToolRelations),
-  dataComponentRelations: many(agentDataComponents),
-  artifactComponentRelations: many(agentArtifactComponents)
+  toolRelations: many(subAgentToolRelations),
+  functionToolRelations: many(agentFunctionToolRelations),
+  dataComponentRelations: many(subAgentDataComponents),
+  artifactComponentRelations: many(subAgentArtifactComponents)
 }));
-drizzleOrm.relations(agentGraph, ({ one }) => ({
+drizzleOrm.relations(agentGraph, ({ one, many }) => ({
   project: one(projects, {
     fields: [agentGraph.tenantId, agentGraph.projectId],
     references: [projects.tenantId, projects.id]
   }),
-  defaultAgent: one(agents, {
-    fields: [agentGraph.defaultAgentId],
-    references: [agents.id]
+  defaultSubAgent: one(subAgents, {
+    fields: [agentGraph.defaultSubAgentId],
+    references: [subAgents.id]
   }),
   contextConfig: one(contextConfigs, {
     fields: [agentGraph.contextConfigId],
     references: [contextConfigs.id]
-  })
+  }),
+  functionTools: many(functionTools)
 }));
 drizzleOrm.relations(externalAgents, ({ one, many }) => ({
   project: one(projects, {
     fields: [externalAgents.tenantId, externalAgents.projectId],
     references: [projects.tenantId, projects.id]
   }),
-  agentRelations: many(agentRelations),
+  subAgentRelations: many(subAgentRelations),
   credentialReference: one(credentialReferences, {
     fields: [externalAgents.credentialReferenceId],
     references: [credentialReferences.id]
@@ -711,13 +753,13 @@ drizzleOrm.relations(apiKeys, ({ one }) => ({
     references: [agentGraph.id]
   })
 }));
-drizzleOrm.relations(agentToolRelations, ({ one }) => ({
-  agent: one(agents, {
-    fields: [agentToolRelations.agentId],
-    references: [agents.id]
+drizzleOrm.relations(subAgentToolRelations, ({ one }) => ({
+  subAgent: one(subAgents, {
+    fields: [subAgentToolRelations.subAgentId],
+    references: [subAgents.id]
   }),
   tool: one(tools, {
-    fields: [agentToolRelations.toolId],
+    fields: [subAgentToolRelations.toolId],
     references: [tools.id]
   })
 }));
@@ -729,14 +771,10 @@ drizzleOrm.relations(tools, ({ one, many }) => ({
     fields: [tools.tenantId, tools.projectId],
     references: [projects.tenantId, projects.id]
   }),
-  agentRelations: many(agentToolRelations),
+  subAgentRelations: many(subAgentToolRelations),
   credentialReference: one(credentialReferences, {
     fields: [tools.credentialReferenceId],
     references: [credentialReferences.id]
-  }),
-  function: one(functions, {
-    fields: [tools.functionId],
-    references: [functions.id]
   })
 }));
 drizzleOrm.relations(conversations, ({ one, many }) => ({
@@ -745,9 +783,9 @@ drizzleOrm.relations(conversations, ({ one, many }) => ({
     references: [projects.tenantId, projects.id]
   }),
   messages: many(messages),
-  activeAgent: one(agents, {
-    fields: [conversations.activeAgentId],
-    references: [agents.id]
+  activeSubAgent: one(subAgents, {
+    fields: [conversations.activeSubAgentId],
+    references: [subAgents.id]
   })
 }));
 drizzleOrm.relations(messages, ({ one, many }) => ({
@@ -755,20 +793,14 @@ drizzleOrm.relations(messages, ({ one, many }) => ({
     fields: [messages.conversationId],
     references: [conversations.id]
   }),
-  // Legacy agent association (consider deprecating)
-  agent: one(agents, {
-    fields: [messages.agentId],
-    references: [agents.id],
-    relationName: "associatedAgent"
-  }),
-  fromAgent: one(agents, {
-    fields: [messages.fromAgentId],
-    references: [agents.id],
+  fromSubAgent: one(subAgents, {
+    fields: [messages.fromSubAgentId],
+    references: [subAgents.id],
     relationName: "sentMessages"
   }),
-  toAgent: one(agents, {
-    fields: [messages.toAgentId],
-    references: [agents.id],
+  toSubAgent: one(subAgents, {
+    fields: [messages.toSubAgentId],
+    references: [subAgents.id],
     relationName: "receivedMessages"
   }),
   fromExternalAgent: one(externalAgents, {
@@ -794,33 +826,40 @@ drizzleOrm.relations(messages, ({ one, many }) => ({
     relationName: "parentChild"
   })
 }));
-drizzleOrm.relations(artifactComponents, ({ many }) => ({
-  agentRelations: many(agentArtifactComponents)
-}));
-drizzleOrm.relations(agentArtifactComponents, ({ one }) => ({
-  agent: one(agents, {
-    fields: [agentArtifactComponents.agentId],
-    references: [agents.id]
+drizzleOrm.relations(artifactComponents, ({ many, one }) => ({
+  project: one(projects, {
+    fields: [artifactComponents.tenantId, artifactComponents.projectId],
+    references: [projects.tenantId, projects.id]
   }),
-  artifactComponent: one(artifactComponents, {
-    fields: [agentArtifactComponents.artifactComponentId],
-    references: [artifactComponents.id]
-  })
+  subAgentRelations: many(subAgentArtifactComponents)
 }));
+drizzleOrm.relations(
+  subAgentArtifactComponents,
+  ({ one }) => ({
+    subAgent: one(subAgents, {
+      fields: [subAgentArtifactComponents.subAgentId],
+      references: [subAgents.id]
+    }),
+    artifactComponent: one(artifactComponents, {
+      fields: [subAgentArtifactComponents.artifactComponentId],
+      references: [artifactComponents.id]
+    })
+  })
+);
 drizzleOrm.relations(dataComponents, ({ many, one }) => ({
   project: one(projects, {
     fields: [dataComponents.tenantId, dataComponents.projectId],
     references: [projects.tenantId, projects.id]
   }),
-  agentRelations: many(agentDataComponents)
+  subAgentRelations: many(subAgentDataComponents)
 }));
-drizzleOrm.relations(agentDataComponents, ({ one }) => ({
-  agent: one(agents, {
-    fields: [agentDataComponents.agentId],
-    references: [agents.id]
+drizzleOrm.relations(subAgentDataComponents, ({ one }) => ({
+  subAgent: one(subAgents, {
+    fields: [subAgentDataComponents.subAgentId],
+    references: [subAgents.id]
   }),
   dataComponent: one(dataComponents, {
-    fields: [agentDataComponents.dataComponentId],
+    fields: [subAgentDataComponents.dataComponentId],
     references: [dataComponents.id]
   })
 }));
@@ -835,28 +874,56 @@ drizzleOrm.relations(ledgerArtifacts, ({ one }) => ({
   })
 }));
 drizzleOrm.relations(functions, ({ many }) => ({
-  tools: many(tools)
+  functionTools: many(functionTools)
 }));
-drizzleOrm.relations(agentRelations, ({ one }) => ({
+drizzleOrm.relations(subAgentRelations, ({ one }) => ({
   graph: one(agentGraph, {
-    fields: [agentRelations.graphId],
+    fields: [subAgentRelations.graphId],
     references: [agentGraph.id]
   }),
-  sourceAgent: one(agents, {
-    fields: [agentRelations.sourceAgentId],
-    references: [agents.id],
+  sourceSubAgent: one(subAgents, {
+    fields: [subAgentRelations.sourceSubAgentId],
+    references: [subAgents.id],
     relationName: "sourceRelations"
   }),
-  targetAgent: one(agents, {
-    fields: [agentRelations.targetAgentId],
-    references: [agents.id],
+  targetSubAgent: one(subAgents, {
+    fields: [subAgentRelations.targetSubAgentId],
+    references: [subAgents.id],
     relationName: "targetRelations"
   }),
   externalAgent: one(externalAgents, {
-    fields: [agentRelations.externalAgentId],
+    fields: [subAgentRelations.externalSubAgentId],
     references: [externalAgents.id]
   })
 }));
+drizzleOrm.relations(functionTools, ({ one, many }) => ({
+  project: one(projects, {
+    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]
+  }),
+  function: one(functions, {
+    fields: [functionTools.tenantId, functionTools.projectId, functionTools.functionId],
+    references: [functions.tenantId, functions.projectId, functions.id]
+  }),
+  agentRelations: many(agentFunctionToolRelations)
+}));
+drizzleOrm.relations(
+  agentFunctionToolRelations,
+  ({ one }) => ({
+    agent: one(subAgents, {
+      fields: [agentFunctionToolRelations.subAgentId],
+      references: [subAgents.id]
+    }),
+    functionTool: one(functionTools, {
+      fields: [agentFunctionToolRelations.functionToolId],
+      references: [functionTools.id]
+    })
+  })
+);
 
 // src/validation/schemas.ts
 var StopWhenSchema = zodOpenapi.z.object({
@@ -864,7 +931,7 @@ var StopWhenSchema = zodOpenapi.z.object({
   stepCountIs: zodOpenapi.z.number().min(1).max(1e3).optional()
 });
 var GraphStopWhenSchema = StopWhenSchema.pick({ transferCountIs: true });
-var AgentStopWhenSchema = StopWhenSchema.pick({ stepCountIs: true });
+var SubAgentStopWhenSchema = StopWhenSchema.pick({ stepCountIs: true });
 var MIN_ID_LENGTH = 1;
 var MAX_ID_LENGTH = 255;
 var URL_SAFE_ID_PATTERN = /^[a-zA-Z0-9\-_.]+$/;
@@ -907,71 +974,73 @@ var createApiUpdateSchema = (schema) => schema.omit({ tenantId: true, projectId:
 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 AgentSelectSchema = drizzleZod.createSelectSchema(agents);
-var AgentInsertSchema = drizzleZod.createInsertSchema(agents).extend({
+var SubAgentSelectSchema = drizzleZod.createSelectSchema(subAgents);
+var SubAgentInsertSchema = drizzleZod.createInsertSchema(subAgents).extend({
   id: resourceIdSchema,
   models: ModelSchema.optional()
 });
-var AgentUpdateSchema = AgentInsertSchema.partial();
-var AgentApiSelectSchema = createGraphScopedApiSchema(AgentSelectSchema);
-var AgentApiInsertSchema = createGraphScopedApiInsertSchema(AgentInsertSchema);
-createGraphScopedApiUpdateSchema(AgentUpdateSchema);
-var AgentRelationSelectSchema = drizzleZod.createSelectSchema(agentRelations);
-var AgentRelationInsertSchema = drizzleZod.createInsertSchema(agentRelations).extend({
+var SubAgentUpdateSchema = SubAgentInsertSchema.partial();
+var SubAgentApiSelectSchema = createGraphScopedApiSchema(SubAgentSelectSchema);
+var SubAgentApiInsertSchema = createGraphScopedApiInsertSchema(SubAgentInsertSchema);
+createGraphScopedApiUpdateSchema(SubAgentUpdateSchema);
+var SubAgentRelationSelectSchema = drizzleZod.createSelectSchema(subAgentRelations);
+var SubAgentRelationInsertSchema = drizzleZod.createInsertSchema(subAgentRelations).extend({
   id: resourceIdSchema,
   graphId: resourceIdSchema,
-  sourceAgentId: resourceIdSchema,
-  targetAgentId: resourceIdSchema.optional(),
-  externalAgentId: resourceIdSchema.optional()
+  sourceSubAgentId: resourceIdSchema,
+  targetSubAgentId: resourceIdSchema.optional(),
+  externalSubAgentId: resourceIdSchema.optional()
 });
-var AgentRelationUpdateSchema = AgentRelationInsertSchema.partial();
-createGraphScopedApiSchema(AgentRelationSelectSchema);
+var SubAgentRelationUpdateSchema = SubAgentRelationInsertSchema.partial();
+createGraphScopedApiSchema(
+  SubAgentRelationSelectSchema
+);
 createGraphScopedApiInsertSchema(
-  AgentRelationInsertSchema
+  SubAgentRelationInsertSchema
 ).extend({
   relationType: zodOpenapi.z.enum(VALID_RELATION_TYPES)
 }).refine(
   (data) => {
-    const hasTarget = data.targetAgentId != null;
-    const hasExternal = data.externalAgentId != null;
+    const hasTarget = data.targetSubAgentId != null;
+    const hasExternal = data.externalSubAgentId != null;
     return hasTarget !== hasExternal;
   },
   {
-    message: "Must specify exactly one of targetAgentId or externalAgentId",
-    path: ["targetAgentId", "externalAgentId"]
+    message: "Must specify exactly one of targetSubAgentId or externalSubAgentId",
+    path: ["targetSubAgentId", "externalSubAgentId"]
   }
 );
 createGraphScopedApiUpdateSchema(
-  AgentRelationUpdateSchema
+  SubAgentRelationUpdateSchema
 ).extend({
   relationType: zodOpenapi.z.enum(VALID_RELATION_TYPES).optional()
 }).refine(
   (data) => {
-    const hasTarget = data.targetAgentId != null;
-    const hasExternal = data.externalAgentId != null;
+    const hasTarget = data.targetSubAgentId != null;
+    const hasExternal = data.externalSubAgentId != 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"]
+    message: "Must specify exactly one of targetSubAgentId or externalSubAgentId when updating sub-agent relationships",
+    path: ["targetSubAgentId", "externalSubAgentId"]
   }
 );
 zodOpenapi.z.object({
-  sourceAgentId: zodOpenapi.z.string().optional(),
-  targetAgentId: zodOpenapi.z.string().optional(),
-  externalAgentId: zodOpenapi.z.string().optional()
+  sourceSubAgentId: zodOpenapi.z.string().optional(),
+  targetSubAgentId: zodOpenapi.z.string().optional(),
+  externalSubAgentId: zodOpenapi.z.string().optional()
 });
-var ExternalAgentRelationInsertSchema = drizzleZod.createInsertSchema(agentRelations).extend({
+var ExternalSubAgentRelationInsertSchema = drizzleZod.createInsertSchema(subAgentRelations).extend({
   id: resourceIdSchema,
   graphId: resourceIdSchema,
-  sourceAgentId: resourceIdSchema,
-  externalAgentId: resourceIdSchema
+  sourceSubAgentId: resourceIdSchema,
+  externalSubAgentId: resourceIdSchema
 });
 createApiInsertSchema(
-  ExternalAgentRelationInsertSchema
+  ExternalSubAgentRelationInsertSchema
 );
 var AgentGraphSelectSchema = drizzleZod.createSelectSchema(agentGraph);
 var AgentGraphInsertSchema = drizzleZod.createInsertSchema(agentGraph).extend({
@@ -1038,32 +1107,22 @@ var ToolSelectSchema = drizzleZod.createSelectSchema(tools);
 var ToolInsertSchema = drizzleZod.createInsertSchema(tools).extend({
   id: resourceIdSchema,
   imageUrl: imageUrlSchema,
-  functionId: resourceIdSchema.optional(),
-  // For function tools, reference to global functions table
-  config: zodOpenapi.z.discriminatedUnion("type", [
-    // MCP tools
-    zodOpenapi.z.object({
-      type: zodOpenapi.z.literal("mcp"),
-      mcp: zodOpenapi.z.object({
-        server: zodOpenapi.z.object({
-          url: zodOpenapi.z.string().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(),
-          sessionId: zodOpenapi.z.string().optional()
-        }).optional(),
-        activeTools: zodOpenapi.z.array(zodOpenapi.z.string()).optional()
-      })
-    }),
-    // Function tools (reference-only, no inline duplication)
-    zodOpenapi.z.object({
-      type: zodOpenapi.z.literal("function")
-      // No inline function details - they're in the functions table via functionId
+  config: zodOpenapi.z.object({
+    type: zodOpenapi.z.literal("mcp"),
+    mcp: zodOpenapi.z.object({
+      server: zodOpenapi.z.object({
+        url: zodOpenapi.z.string().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(),
+        sessionId: zodOpenapi.z.string().optional()
+      }).optional(),
+      activeTools: zodOpenapi.z.array(zodOpenapi.z.string()).optional()
     })
-  ])
+  })
 });
 var ConversationSelectSchema = drizzleZod.createSelectSchema(conversations);
 var ConversationInsertSchema = drizzleZod.createInsertSchema(conversations).extend({
@@ -1102,20 +1161,20 @@ 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();
+var SubAgentDataComponentSelectSchema = drizzleZod.createSelectSchema(subAgentDataComponents);
+var SubAgentDataComponentInsertSchema = drizzleZod.createInsertSchema(subAgentDataComponents);
+var SubAgentDataComponentUpdateSchema = SubAgentDataComponentInsertSchema.partial();
 createGraphScopedApiSchema(
-  AgentDataComponentSelectSchema
+  SubAgentDataComponentSelectSchema
 );
-AgentDataComponentInsertSchema.omit({
+SubAgentDataComponentInsertSchema.omit({
   tenantId: true,
   projectId: true,
   id: true,
   createdAt: true
 });
 createGraphScopedApiUpdateSchema(
-  AgentDataComponentUpdateSchema
+  SubAgentDataComponentUpdateSchema
 );
 var ArtifactComponentSelectSchema = drizzleZod.createSelectSchema(artifactComponents);
 var ArtifactComponentInsertSchema = drizzleZod.createInsertSchema(artifactComponents).extend({
@@ -1132,26 +1191,26 @@ var ArtifactComponentApiInsertSchema = ArtifactComponentInsertSchema.omit({
 createApiUpdateSchema(
   ArtifactComponentUpdateSchema
 );
-var AgentArtifactComponentSelectSchema = drizzleZod.createSelectSchema(agentArtifactComponents);
-var AgentArtifactComponentInsertSchema = drizzleZod.createInsertSchema(
-  agentArtifactComponents
+var SubAgentArtifactComponentSelectSchema = drizzleZod.createSelectSchema(subAgentArtifactComponents);
+var SubAgentArtifactComponentInsertSchema = drizzleZod.createInsertSchema(
+  subAgentArtifactComponents
 ).extend({
   id: resourceIdSchema,
-  agentId: resourceIdSchema,
+  subAgentId: resourceIdSchema,
   artifactComponentId: resourceIdSchema
 });
-var AgentArtifactComponentUpdateSchema = AgentArtifactComponentInsertSchema.partial();
+var SubAgentArtifactComponentUpdateSchema = SubAgentArtifactComponentInsertSchema.partial();
 createGraphScopedApiSchema(
-  AgentArtifactComponentSelectSchema
+  SubAgentArtifactComponentSelectSchema
 );
-AgentArtifactComponentInsertSchema.omit({
+SubAgentArtifactComponentInsertSchema.omit({
   tenantId: true,
   projectId: true,
   id: true,
   createdAt: true
 });
 createGraphScopedApiUpdateSchema(
-  AgentArtifactComponentUpdateSchema
+  SubAgentArtifactComponentUpdateSchema
 );
 var ExternalAgentSelectSchema = drizzleZod.createSelectSchema(externalAgents).extend({
   credentialReferenceId: zodOpenapi.z.string().nullable().optional(),
@@ -1165,7 +1224,7 @@ var ExternalAgentApiSelectSchema = createGraphScopedApiSchema(ExternalAgentSelec
 var ExternalAgentApiInsertSchema = createGraphScopedApiInsertSchema(ExternalAgentInsertSchema);
 createGraphScopedApiUpdateSchema(ExternalAgentUpdateSchema);
 zodOpenapi.z.discriminatedUnion("type", [
-  AgentApiSelectSchema.extend({ type: zodOpenapi.z.literal("internal") }),
+  SubAgentApiSelectSchema.extend({ type: zodOpenapi.z.literal("internal") }),
   ExternalAgentApiSelectSchema.extend({ type: zodOpenapi.z.literal("external") })
 ]);
 var ApiKeySelectSchema = drizzleZod.createSelectSchema(apiKeys);
@@ -1272,6 +1331,14 @@ var ToolUpdateSchema = ToolInsertSchema.partial();
 createApiSchema(ToolSelectSchema);
 var ToolApiInsertSchema = createApiInsertSchema(ToolInsertSchema);
 createApiUpdateSchema(ToolUpdateSchema);
+var FunctionToolSelectSchema = drizzleZod.createSelectSchema(functionTools);
+var FunctionToolInsertSchema = drizzleZod.createInsertSchema(functionTools).extend({
+  id: resourceIdSchema
+});
+var FunctionToolUpdateSchema = FunctionToolInsertSchema.partial();
+createApiSchema(FunctionToolSelectSchema);
+var FunctionToolApiInsertSchema = createGraphScopedApiInsertSchema(FunctionToolInsertSchema);
+createApiUpdateSchema(FunctionToolUpdateSchema);
 var FunctionSelectSchema = drizzleZod.createSelectSchema(functions);
 var FunctionInsertSchema = drizzleZod.createInsertSchema(functions).extend({
   id: resourceIdSchema
@@ -1319,23 +1386,23 @@ var ContextConfigApiInsertSchema = createApiInsertSchema(ContextConfigInsertSche
 createApiUpdateSchema(ContextConfigUpdateSchema).omit({
   graphId: true
 });
-var AgentToolRelationSelectSchema = drizzleZod.createSelectSchema(agentToolRelations);
-var AgentToolRelationInsertSchema = drizzleZod.createInsertSchema(agentToolRelations).extend({
+var SubAgentToolRelationSelectSchema = drizzleZod.createSelectSchema(subAgentToolRelations);
+var SubAgentToolRelationInsertSchema = drizzleZod.createInsertSchema(subAgentToolRelations).extend({
   id: resourceIdSchema,
-  agentId: resourceIdSchema,
+  subAgentId: resourceIdSchema,
   toolId: resourceIdSchema,
   selectedTools: zodOpenapi.z.array(zodOpenapi.z.string()).nullish(),
   headers: zodOpenapi.z.record(zodOpenapi.z.string(), zodOpenapi.z.string()).nullish()
 });
-var AgentToolRelationUpdateSchema = AgentToolRelationInsertSchema.partial();
+var SubAgentToolRelationUpdateSchema = SubAgentToolRelationInsertSchema.partial();
 createGraphScopedApiSchema(
-  AgentToolRelationSelectSchema
+  SubAgentToolRelationSelectSchema
 );
 createGraphScopedApiInsertSchema(
-  AgentToolRelationInsertSchema
+  SubAgentToolRelationInsertSchema
 );
 createGraphScopedApiUpdateSchema(
-  AgentToolRelationUpdateSchema
+  SubAgentToolRelationUpdateSchema
 );
 var LedgerArtifactSelectSchema = drizzleZod.createSelectSchema(ledgerArtifacts);
 var LedgerArtifactInsertSchema = drizzleZod.createInsertSchema(ledgerArtifacts);
@@ -1365,7 +1432,7 @@ var CanUseItemSchema = zodOpenapi.z.object({
   toolSelection: zodOpenapi.z.array(zodOpenapi.z.string()).nullish(),
   headers: zodOpenapi.z.record(zodOpenapi.z.string(), zodOpenapi.z.string()).nullish()
 });
-var FullGraphAgentInsertSchema = AgentApiInsertSchema.extend({
+var FullGraphAgentInsertSchema = SubAgentApiInsertSchema.extend({
   type: zodOpenapi.z.literal("internal"),
   canUse: zodOpenapi.z.array(CanUseItemSchema),
   // All tools (both MCP and function tools)
@@ -1375,10 +1442,15 @@ var FullGraphAgentInsertSchema = AgentApiInsertSchema.extend({
   canDelegateTo: zodOpenapi.z.array(zodOpenapi.z.string()).optional()
 });
 AgentGraphApiInsertSchema.extend({
-  agents: zodOpenapi.z.record(zodOpenapi.z.string(), zodOpenapi.z.union([FullGraphAgentInsertSchema, ExternalAgentApiInsertSchema])),
+  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(),
-  // Get tool name/description from toolId
+  // 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),
@@ -1388,13 +1460,20 @@ AgentGraphApiInsertSchema.extend({
   graphPrompt: zodOpenapi.z.string().max(5e3, "Graph prompt cannot exceed 5000 characters").optional()
 });
 var GraphWithinContextOfProjectSchema = AgentGraphApiInsertSchema.extend({
-  agents: zodOpenapi.z.record(
+  subAgents: zodOpenapi.z.record(
     zodOpenapi.z.string(),
     zodOpenapi.z.discriminatedUnion("type", [
       FullGraphAgentInsertSchema,
       ExternalAgentApiInsertSchema.extend({ type: zodOpenapi.z.literal("external") })
     ])
   ),
+  // 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(),
@@ -1435,9 +1514,9 @@ ProjectUpdateSchema.omit({ tenantId: true });
 ProjectApiInsertSchema.extend({
   graphs: zodOpenapi.z.record(zodOpenapi.z.string(), GraphWithinContextOfProjectSchema),
   tools: zodOpenapi.z.record(zodOpenapi.z.string(), ToolApiInsertSchema),
-  // Now includes both MCP and function tools
+  // MCP tools (project-scoped)
   functions: zodOpenapi.z.record(zodOpenapi.z.string(), FunctionApiInsertSchema).optional(),
-  // Global functions
+  // 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),
@@ -1459,72 +1538,46 @@ zodOpenapi.z.object({
     example: "graph_789"
   })
 });
-zodOpenapi.z.object({
-  tenantId: zodOpenapi.z.string().openapi({
-    description: "Tenant identifier",
-    example: "tenant_123"
-  })
+var TenantId = zodOpenapi.z.string().openapi({
+  description: "Tenant identifier",
+  example: "tenant_123"
+});
+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 SubAgentId = zodOpenapi.z.string().openapi({
+  description: "Sub-agent identifier",
+  example: "sub_agent_123"
+});
+var TenantParamsSchema = zodOpenapi.z.object({
+  tenantId: TenantId
 }).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"
-  }),
-  graphId: zodOpenapi.z.string().openapi({
-    description: "Graph identifier",
-    example: "graph_789"
-  })
-}).openapi("TenantProjectGraphParams");
-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"
-  }),
-  graphId: zodOpenapi.z.string().openapi({
-    description: "Graph identifier",
-    example: "graph_789"
-  }),
+TenantParamsSchema.extend({
   id: resourceIdSchema
-}).openapi("TenantProjectGraphIdParams");
-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("TenantIdParams");
+var TenantProjectParamsSchema = TenantParamsSchema.extend({
+  projectId: ProjectId
+}).openapi("TenantProjectParams");
+TenantProjectParamsSchema.extend({
   id: resourceIdSchema
 }).openapi("TenantProjectIdParams");
-zodOpenapi.z.object({
-  tenantId: zodOpenapi.z.string().openapi({
-    description: "Tenant identifier",
-    example: "tenant_123"
-  }),
+var TenantProjectGraphParamsSchema = TenantProjectParamsSchema.extend({
+  graphId: GraphId
+}).openapi("TenantProjectGraphParams");
+TenantProjectGraphParamsSchema.extend({
   id: resourceIdSchema
-}).openapi("TenantIdParams");
-zodOpenapi.z.object({
+}).openapi("TenantProjectGraphIdParams");
+var TenantProjectGraphSubAgentParamsSchema = TenantProjectGraphParamsSchema.extend({
+  subAgentId: SubAgentId
+}).openapi("TenantProjectGraphSubAgentParams");
+TenantProjectGraphSubAgentParamsSchema.extend({
   id: resourceIdSchema
-}).openapi("IdParams");
+}).openapi("TenantProjectGraphSubAgentIdParams");
 zodOpenapi.z.object({
   page: zodOpenapi.z.coerce.number().min(1).default(1),
   limit: zodOpenapi.z.coerce.number().min(1).max(100).default(10)
@@ -1632,6 +1685,283 @@ function validatePropsAsJsonSchema(props) {
   }
 }
 
+// src/constants/otel-attributes.ts
+var DELEGATION_FROM_SUB_AGENT_ID = "delegation.from_sub_agent_id";
+var DELEGATION_TO_SUB_AGENT_ID = "delegation.to_sub_agent_id";
+var DELEGATION_ID = "delegation.id";
+var TRANSFER_FROM_SUB_AGENT_ID = "transfer.from_sub_agent_id";
+var TRANSFER_TO_SUB_AGENT_ID = "transfer.to_sub_agent_id";
+var SPAN_NAMES = {
+  AI_TOOL_CALL: "ai.toolCall",
+  CONTEXT_RESOLUTION: "context-resolver.resolve_single_fetch_definition",
+  CONTEXT_HANDLE: "context.handle_context_resolution",
+  AGENT_GENERATION: "agent.generate",
+  CONTEXT_FETCHER: "context-fetcher.http-request",
+  ARTIFACT_PROCESSING: "graph_session.process_artifact"
+};
+var AI_OPERATIONS = {
+  GENERATE_TEXT: "ai.generateText.doGenerate",
+  STREAM_TEXT: "ai.streamText.doStream"
+};
+var SPAN_KEYS = {
+  // Core span attributes
+  SPAN_ID: "spanID",
+  TRACE_ID: "traceID",
+  DURATION_NANO: "durationNano",
+  TIMESTAMP: "timestamp",
+  HAS_ERROR: "hasError",
+  STATUS_MESSAGE: "status_message",
+  OTEL_STATUS_CODE: "otel.status_code",
+  OTEL_STATUS_DESCRIPTION: "otel.status_description",
+  // Graph attributes
+  GRAPH_ID: "graph.id",
+  GRAPH_NAME: "graph.name",
+  TENANT_ID: "tenant.id",
+  PROJECT_ID: "project.id",
+  // AI/Agent attributes
+  AI_AGENT_NAME: "ai.agentName",
+  AI_AGENT_NAME_ALT: "ai.agent.name",
+  AI_OPERATION_ID: "ai.operationId",
+  AI_RESPONSE_TIMESTAMP: "ai.response.timestamp",
+  AI_RESPONSE_CONTENT: "ai.response.content",
+  AI_RESPONSE_TEXT: "ai.response.text",
+  AI_RESPONSE_MODEL: "ai.response.model",
+  AI_RESPONSE_TOOL_CALLS: "ai.response.toolCalls",
+  AI_PROMPT_MESSAGES: "ai.prompt.messages",
+  AI_MODEL_PROVIDER: "ai.model.provider",
+  AI_TELEMETRY_FUNCTION_ID: "ai.telemetry.functionId",
+  AI_MODEL_ID: "ai.model.id",
+  // Tool attributes
+  AI_TOOL_CALL_NAME: "ai.toolCall.name",
+  AI_TOOL_CALL_RESULT: "ai.toolCall.result",
+  AI_TOOL_CALL_ARGS: "ai.toolCall.args",
+  AI_TOOL_CALL_ID: "ai.toolCall.id",
+  AI_TOOL_TYPE: "ai.toolType",
+  TOOL_PURPOSE: "tool.purpose",
+  // Agent attributes
+  AGENT_ID: "agent.id",
+  AGENT_NAME: "agent.name",
+  // Token usage
+  GEN_AI_USAGE_INPUT_TOKENS: "gen_ai.usage.input_tokens",
+  GEN_AI_USAGE_OUTPUT_TOKENS: "gen_ai.usage.output_tokens",
+  // Context attributes
+  CONTEXT_URL: "context.url",
+  CONTEXT_CONFIG_ID: "context.context_config_id",
+  CONTEXT_AGENT_GRAPH_ID: "context.agent_graph_id",
+  CONTEXT_HEADERS_KEYS: "context.headers_keys",
+  // Message attributes
+  MESSAGE_CONTENT: "message.content",
+  MESSAGE_TIMESTAMP: "message.timestamp",
+  MCP_TOOL_DESCRIPTION: "mcp.tool.description",
+  // Delegation/Transfer attributes
+  DELEGATION_FROM_SUB_AGENT_ID,
+  DELEGATION_TO_SUB_AGENT_ID,
+  DELEGATION_ID,
+  TRANSFER_FROM_SUB_AGENT_ID,
+  TRANSFER_TO_SUB_AGENT_ID,
+  // HTTP attributes
+  HTTP_URL: "http.url",
+  HTTP_STATUS_CODE: "http.status_code",
+  HTTP_RESPONSE_BODY_SIZE: "http.response.body_size",
+  // Core attributes
+  NAME: "name",
+  PARENT_SPAN_ID: "parentSpanID",
+  CONVERSATION_ID: "conversation.id",
+  // Artifact processing attributes
+  ARTIFACT_ID: "artifact.id",
+  ARTIFACT_TYPE: "artifact.type",
+  ARTIFACT_AGENT_ID: "artifact.agent_id",
+  ARTIFACT_TOOL_CALL_ID: "artifact.tool_call_id",
+  ARTIFACT_DATA: "artifact.data",
+  ARTIFACT_NAME: "artifact.name",
+  ARTIFACT_DESCRIPTION: "artifact.description"
+};
+var UNKNOWN_VALUE = "unknown";
+var ACTIVITY_TYPES = {
+  TOOL_CALL: "tool_call",
+  AI_GENERATION: "ai_generation",
+  AGENT_GENERATION: "agent_generation",
+  CONTEXT_FETCH: "context_fetch",
+  CONTEXT_RESOLUTION: "context_resolution",
+  USER_MESSAGE: "user_message",
+  AI_ASSISTANT_MESSAGE: "ai_assistant_message",
+  AI_MODEL_STREAMED_TEXT: "ai_model_streamed_text"
+};
+var ACTIVITY_STATUS = {
+  SUCCESS: "success",
+  ERROR: "error",
+  PENDING: "pending"
+};
+var AGENT_IDS = {
+  USER: "user",
+  AI_ASSISTANT: "ai-assistant"
+};
+var ACTIVITY_NAMES = {
+  CONTEXT_FETCH: "Context Fetch",
+  USER_MESSAGE: "User Message",
+  AI_ASSISTANT_MESSAGE: "AI Assistant Message",
+  AI_TEXT_GENERATION: "AI Text Generation",
+  AI_STREAMING_TEXT: "AI Streaming Text",
+  UNKNOWN_AGENT: "Unknown Agent",
+  USER: "User"
+};
+var AI_TOOL_TYPES = {
+  MCP: "mcp",
+  TRANSFER: "transfer",
+  DELEGATION: "delegation"
+};
+
+// src/constants/signoz-queries.ts
+var DATA_TYPES = {
+  STRING: "string",
+  INT64: "int64",
+  FLOAT64: "float64",
+  BOOL: "bool"
+};
+var FIELD_TYPES = {
+  TAG: "tag",
+  RESOURCE: "resource"
+};
+var QUERY_FIELD_CONFIGS = {
+  // String tag fields
+  STRING_TAG: {
+    dataType: DATA_TYPES.STRING,
+    type: FIELD_TYPES.TAG,
+    isColumn: false
+  },
+  STRING_TAG_COLUMN: {
+    dataType: DATA_TYPES.STRING,
+    type: FIELD_TYPES.TAG,
+    isColumn: true
+  },
+  // Numeric tag fields
+  INT64_TAG: {
+    dataType: DATA_TYPES.INT64,
+    type: FIELD_TYPES.TAG,
+    isColumn: false
+  },
+  INT64_TAG_COLUMN: {
+    dataType: DATA_TYPES.INT64,
+    type: FIELD_TYPES.TAG,
+    isColumn: true
+  },
+  FLOAT64_TAG: {
+    dataType: DATA_TYPES.FLOAT64,
+    type: FIELD_TYPES.TAG,
+    isColumn: false
+  },
+  FLOAT64_TAG_COLUMN: {
+    dataType: DATA_TYPES.FLOAT64,
+    type: FIELD_TYPES.TAG,
+    isColumn: true
+  },
+  // Boolean tag fields
+  BOOL_TAG: {
+    dataType: DATA_TYPES.BOOL,
+    type: FIELD_TYPES.TAG,
+    isColumn: false
+  },
+  BOOL_TAG_COLUMN: {
+    dataType: DATA_TYPES.BOOL,
+    type: FIELD_TYPES.TAG,
+    isColumn: true
+  }
+};
+var OPERATORS = {
+  // Comparison operators
+  EQUALS: "=",
+  NOT_EQUALS: "!=",
+  LESS_THAN: "<",
+  GREATER_THAN: ">",
+  LESS_THAN_OR_EQUAL: "<=",
+  GREATER_THAN_OR_EQUAL: ">=",
+  // String operators
+  LIKE: "like",
+  NOT_LIKE: "nlike",
+  // Existence operators
+  EXISTS: "exists",
+  NOT_EXISTS: "nexists",
+  // Logical operators
+  AND: "AND",
+  OR: "OR"
+};
+var QUERY_EXPRESSIONS = {
+  SPAN_NAMES: "spanNames",
+  AGENT_MODEL_CALLS: "agentModelCalls",
+  MODEL_CALLS: "modelCalls",
+  LAST_ACTIVITY: "lastActivity",
+  CONVERSATION_METADATA: "conversationMetadata",
+  FILTERED_CONVERSATIONS: "filteredConversations",
+  TOOLS: "tools",
+  TRANSFERS: "transfers",
+  DELEGATIONS: "delegations",
+  AI_CALLS: "aiCalls",
+  CONTEXT_ERRORS: "contextErrors",
+  AGENT_GENERATION_ERRORS: "agentGenerationErrors",
+  USER_MESSAGES: "userMessages",
+  UNIQUE_GRAPHS: "uniqueGraphs",
+  UNIQUE_MODELS: "uniqueModels",
+  // Route-specific query names
+  TOOL_CALLS: "toolCalls",
+  CONTEXT_RESOLUTION: "contextResolution",
+  CONTEXT_HANDLE: "contextHandle",
+  AI_ASSISTANT_MESSAGES: "aiAssistantMessages",
+  AI_GENERATIONS: "aiGenerations",
+  AI_STREAMING_TEXT: "aiStreamingText",
+  CONTEXT_FETCHERS: "contextFetchers",
+  DURATION_SPANS: "durationSpans",
+  AGENT_GENERATIONS: "agentGenerations",
+  SPANS_WITH_ERRORS: "spansWithErrors",
+  ARTIFACT_PROCESSING: "artifactProcessing"
+};
+var REDUCE_OPERATIONS = {
+  SUM: "sum",
+  MAX: "max",
+  MIN: "min",
+  AVG: "avg",
+  COUNT: "count"
+};
+var ORDER_DIRECTIONS = {
+  ASC: "asc",
+  DESC: "desc"
+};
+var QUERY_TYPES = {
+  BUILDER: "builder",
+  CLICKHOUSE: "clickhouse",
+  PROMQL: "promql"
+};
+var PANEL_TYPES = {
+  LIST: "list",
+  TABLE: "table",
+  GRAPH: "graph",
+  VALUE: "value"
+};
+var DATA_SOURCES = {
+  TRACES: "traces",
+  METRICS: "metrics",
+  LOGS: "logs"
+};
+var AGGREGATE_OPERATORS = {
+  COUNT: "count",
+  SUM: "sum",
+  AVG: "avg",
+  MIN: "min",
+  MAX: "max",
+  NOOP: "noop"
+};
+var QUERY_DEFAULTS = {
+  STEP: 60,
+  STEP_INTERVAL: 60,
+  OFFSET: 0,
+  DISABLED: false,
+  HAVING: [],
+  LEGEND: "",
+  LIMIT_NULL: null,
+  LIMIT_ZERO: 0,
+  LIMIT_1000: 1e3,
+  EMPTY_GROUP_BY: []
+};
+
 // src/client-exports.ts
 var TenantParamsSchema2 = zod.z.object({
   tenantId: zod.z.string()
@@ -1642,7 +1972,7 @@ var TenantProjectParamsSchema2 = TenantParamsSchema2.extend({
 var TenantProjectIdParamsSchema2 = TenantProjectParamsSchema2.extend({
   id: zod.z.string()
 });
-var IdParamsSchema2 = zod.z.object({
+var IdParamsSchema = zod.z.object({
   id: zod.z.string()
 });
 var PaginationSchema2 = zod.z.object({
@@ -1663,7 +1993,7 @@ var ErrorResponseSchema2 = zod.z.object({
   message: zod.z.string().optional(),
   details: zod.z.unknown().optional()
 });
-var AgentApiInsertSchema2 = zod.z.object({
+var AgentApiInsertSchema = zod.z.object({
   id: zod.z.string().optional(),
   name: zod.z.string(),
   description: zod.z.string().optional(),
@@ -1739,10 +2069,10 @@ var AgentGraphApiInsertSchema2 = zod.z.object({
   id: zod.z.string().optional(),
   name: zod.z.string(),
   description: zod.z.string().optional(),
-  defaultAgentId: zod.z.string().optional()
+  defaultSubAgentId: zod.z.string().optional()
 });
 var FullGraphDefinitionSchema2 = AgentGraphApiInsertSchema2.extend({
-  agents: zod.z.record(
+  subAgents: zod.z.record(
     zod.z.string(),
     zod.z.union([
       FullGraphAgentInsertSchema,
@@ -1801,37 +2131,63 @@ 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.ACTIVITY_NAMES = ACTIVITY_NAMES;
+exports.ACTIVITY_STATUS = ACTIVITY_STATUS;
+exports.ACTIVITY_TYPES = ACTIVITY_TYPES;
+exports.AGENT_IDS = AGENT_IDS;
+exports.AGGREGATE_OPERATORS = AGGREGATE_OPERATORS;
+exports.AI_OPERATIONS = AI_OPERATIONS;
+exports.AI_TOOL_TYPES = AI_TOOL_TYPES;
+exports.AgentApiInsertSchema = AgentApiInsertSchema;
 exports.AgentGraphApiInsertSchema = AgentGraphApiInsertSchema2;
-exports.AgentStopWhenSchema = AgentStopWhenSchema;
+exports.AgentStopWhenSchema = SubAgentStopWhenSchema;
 exports.ApiKeyApiCreationResponseSchema = ApiKeyApiCreationResponseSchema2;
 exports.ApiKeyApiSelectSchema = ApiKeyApiSelectSchema2;
 exports.ArtifactComponentApiInsertSchema = ArtifactComponentApiInsertSchema2;
 exports.ContextConfigApiInsertSchema = ContextConfigApiInsertSchema2;
 exports.CredentialReferenceApiInsertSchema = CredentialReferenceApiInsertSchema2;
 exports.CredentialStoreType = CredentialStoreType;
+exports.DATA_SOURCES = DATA_SOURCES;
+exports.DATA_TYPES = DATA_TYPES;
+exports.DELEGATION_FROM_SUB_AGENT_ID = DELEGATION_FROM_SUB_AGENT_ID;
+exports.DELEGATION_ID = DELEGATION_ID;
+exports.DELEGATION_TO_SUB_AGENT_ID = DELEGATION_TO_SUB_AGENT_ID;
 exports.DataComponentApiInsertSchema = DataComponentApiInsertSchema2;
 exports.ErrorResponseSchema = ErrorResponseSchema2;
 exports.ExternalAgentApiInsertSchema = ExternalAgentApiInsertSchema2;
+exports.FIELD_TYPES = FIELD_TYPES;
 exports.FullGraphDefinitionSchema = FullGraphDefinitionSchema2;
 exports.FunctionApiInsertSchema = FunctionApiInsertSchema;
 exports.FunctionApiSelectSchema = FunctionApiSelectSchema;
 exports.FunctionApiUpdateSchema = FunctionApiUpdateSchema;
 exports.GraphStopWhenSchema = GraphStopWhenSchema;
-exports.IdParamsSchema = IdParamsSchema2;
+exports.IdParamsSchema = IdParamsSchema;
 exports.ListResponseSchema = ListResponseSchema;
 exports.MAX_ID_LENGTH = MAX_ID_LENGTH2;
 exports.MCPTransportType = MCPTransportType;
 exports.MIN_ID_LENGTH = MIN_ID_LENGTH2;
 exports.ModelSettingsSchema = ModelSettingsSchema;
+exports.OPERATORS = OPERATORS;
+exports.ORDER_DIRECTIONS = ORDER_DIRECTIONS;
+exports.PANEL_TYPES = PANEL_TYPES;
 exports.PaginationSchema = PaginationSchema2;
+exports.QUERY_DEFAULTS = QUERY_DEFAULTS;
+exports.QUERY_EXPRESSIONS = QUERY_EXPRESSIONS;
+exports.QUERY_FIELD_CONFIGS = QUERY_FIELD_CONFIGS;
+exports.QUERY_TYPES = QUERY_TYPES;
+exports.REDUCE_OPERATIONS = REDUCE_OPERATIONS;
+exports.SPAN_KEYS = SPAN_KEYS;
+exports.SPAN_NAMES = SPAN_NAMES;
 exports.SandboxConfigSchema = SandboxConfigSchema;
 exports.SingleResponseSchema = SingleResponseSchema;
 exports.StopWhenSchema = StopWhenSchema;
+exports.TRANSFER_FROM_SUB_AGENT_ID = TRANSFER_FROM_SUB_AGENT_ID;
+exports.TRANSFER_TO_SUB_AGENT_ID = TRANSFER_TO_SUB_AGENT_ID;
 exports.TenantParamsSchema = TenantParamsSchema2;
 exports.TenantProjectIdParamsSchema = TenantProjectIdParamsSchema2;
 exports.TenantProjectParamsSchema = TenantProjectParamsSchema2;
 exports.ToolApiInsertSchema = ToolApiInsertSchema2;
+exports.UNKNOWN_VALUE = UNKNOWN_VALUE;
 exports.URL_SAFE_ID_PATTERN = URL_SAFE_ID_PATTERN2;
 exports.generateIdFromName = generateIdFromName;
 exports.resourceIdSchema = resourceIdSchema2;