@inkeep/agents-core 0.0.0-dev-20251009194333 → 0.0.0-dev-20251009215610

package/dist/index.cjs

@@ -64,6 +64,276 @@ async function apiFetch(url, options = {}) {
     headers: headers2
   });
 }
+
+// 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"
+};
+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"
+};
+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 TOOL_NAMES = {
+  SAVE_TOOL_RESULT: "save_tool_result"
+};
+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"
+};
+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: []
+};
 var generateId = nanoid.customAlphabet("abcdefghijklmnopqrstuvwxyz0123456789", 21);
 function getConversationId() {
   return generateId();
@@ -286,18 +556,9 @@ function extractPreviewFields(schema) {
 // src/db/schema.ts
 var schema_exports = {};
 __export(schema_exports, {
-  agentArtifactComponents: () => agentArtifactComponents,
-  agentArtifactComponentsRelations: () => agentArtifactComponentsRelations,
-  agentDataComponents: () => agentDataComponents,
-  agentDataComponentsRelations: () => agentDataComponentsRelations,
   agentGraph: () => agentGraph,
   agentGraphRelations: () => agentGraphRelations,
-  agentRelations: () => agentRelations,
-  agentRelationsRelations: () => agentRelationsRelations,
-  agentToolRelations: () => agentToolRelations,
   agentToolRelationsRelations: () => agentToolRelationsRelations,
-  agents: () => agents,
-  agentsRelations: () => agentsRelations,
   apiKeys: () => apiKeys,
   apiKeysRelations: () => apiKeysRelations,
   artifactComponents: () => artifactComponents,
@@ -322,6 +583,15 @@ __export(schema_exports, {
   messagesRelations: () => messagesRelations,
   projects: () => projects,
   projectsRelations: () => projectsRelations,
+  subAgentArtifactComponents: () => subAgentArtifactComponents,
+  subAgentArtifactComponentsRelations: () => subAgentArtifactComponentsRelations,
+  subAgentDataComponents: () => subAgentDataComponents,
+  subAgentDataComponentsRelations: () => subAgentDataComponentsRelations,
+  subAgentRelations: () => subAgentRelations,
+  subAgentRelationsRelations: () => subAgentRelationsRelations,
+  subAgentToolRelations: () => subAgentToolRelations,
+  subAgents: () => subAgents,
+  subAgentsRelations: () => subAgentsRelations,
   taskRelations: () => taskRelations,
   taskRelationsRelations: () => taskRelationsRelations,
   tasks: () => tasks,
@@ -341,9 +611,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(),
@@ -374,7 +644,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
@@ -453,8 +723,8 @@ var contextCache = sqliteCore.sqliteTable(
     )
   ]
 );
-var agents = sqliteCore.sqliteTable(
-  "agents",
+var subAgents = sqliteCore.sqliteTable(
+  "sub_agents",
   {
     ...graphScoped,
     ...uiProperties,
@@ -476,17 +746,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) => [
@@ -494,7 +763,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")
   ]
 );
@@ -530,7 +799,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(),
@@ -539,9 +808,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")
   ]
 );
@@ -581,10 +850,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`)
   },
@@ -592,15 +861,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")
   ]
 );
@@ -621,22 +890,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({
@@ -646,7 +915,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")
   ]
 );
@@ -702,10 +971,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(),
@@ -715,15 +984,15 @@ 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
     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")
   ]
 );
@@ -732,7 +1001,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(),
@@ -756,15 +1025,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(),
@@ -773,8 +1042,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
@@ -901,10 +1168,9 @@ var tasksRelations = 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),
@@ -912,7 +1178,7 @@ var tasksRelations = drizzleOrm.relations(tasks, ({ one, many }) => ({
   ledgerArtifacts: many(ledgerArtifacts)
 }));
 var projectsRelations = drizzleOrm.relations(projects, ({ many }) => ({
-  agents: many(agents),
+  subAgents: many(subAgents),
   agentGraphs: many(agentGraph),
   tools: many(tools),
   contextConfigs: many(contextConfigs),
@@ -950,17 +1216,17 @@ var contextCacheRelations = drizzleOrm.relations(contextCache, ({ one }) => ({
     references: [contextConfigs.id]
   })
 }));
-var agentsRelations = drizzleOrm.relations(agents, ({ many, one }) => ({
+var subAgentsRelations = 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, {
@@ -972,18 +1238,18 @@ var agentsRelations = drizzleOrm.relations(agents, ({ many, one }) => ({
   associatedMessages: many(messages, {
     relationName: "associatedAgent"
   }),
-  toolRelations: many(agentToolRelations),
-  dataComponentRelations: many(agentDataComponents),
-  artifactComponentRelations: many(agentArtifactComponents)
+  toolRelations: many(subAgentToolRelations),
+  dataComponentRelations: many(subAgentDataComponents),
+  artifactComponentRelations: many(subAgentArtifactComponents)
 }));
 var agentGraphRelations = drizzleOrm.relations(agentGraph, ({ one }) => ({
   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],
@@ -995,7 +1261,7 @@ var externalAgentsRelations = drizzleOrm.relations(externalAgents, ({ one, many
     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]
@@ -1011,13 +1277,13 @@ var apiKeysRelations = drizzleOrm.relations(apiKeys, ({ one }) => ({
     references: [agentGraph.id]
   })
 }));
-var agentToolRelationsRelations = drizzleOrm.relations(agentToolRelations, ({ one }) => ({
-  agent: one(agents, {
-    fields: [agentToolRelations.agentId],
-    references: [agents.id]
+var agentToolRelationsRelations = 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]
   })
 }));
@@ -1029,7 +1295,7 @@ var toolsRelations = 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]
@@ -1045,9 +1311,9 @@ var conversationsRelations = 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]
   })
 }));
 var messagesRelations = drizzleOrm.relations(messages, ({ one, many }) => ({
@@ -1055,20 +1321,14 @@ var messagesRelations = 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, {
@@ -1094,33 +1354,40 @@ var messagesRelations = drizzleOrm.relations(messages, ({ one, many }) => ({
     relationName: "parentChild"
   })
 }));
-var artifactComponentsRelations = drizzleOrm.relations(artifactComponents, ({ many }) => ({
-  agentRelations: many(agentArtifactComponents)
-}));
-var agentArtifactComponentsRelations = drizzleOrm.relations(agentArtifactComponents, ({ one }) => ({
-  agent: one(agents, {
-    fields: [agentArtifactComponents.agentId],
-    references: [agents.id]
+var artifactComponentsRelations = 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)
 }));
+var subAgentArtifactComponentsRelations = drizzleOrm.relations(
+  subAgentArtifactComponents,
+  ({ one }) => ({
+    subAgent: one(subAgents, {
+      fields: [subAgentArtifactComponents.subAgentId],
+      references: [subAgents.id]
+    }),
+    artifactComponent: one(artifactComponents, {
+      fields: [subAgentArtifactComponents.artifactComponentId],
+      references: [artifactComponents.id]
+    })
+  })
+);
 var dataComponentsRelations = drizzleOrm.relations(dataComponents, ({ many, one }) => ({
   project: one(projects, {
     fields: [dataComponents.tenantId, dataComponents.projectId],
     references: [projects.tenantId, projects.id]
   }),
-  agentRelations: many(agentDataComponents)
+  subAgentRelations: many(subAgentDataComponents)
 }));
-var agentDataComponentsRelations = drizzleOrm.relations(agentDataComponents, ({ one }) => ({
-  agent: one(agents, {
-    fields: [agentDataComponents.agentId],
-    references: [agents.id]
+var subAgentDataComponentsRelations = 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]
   })
 }));
@@ -1137,23 +1404,23 @@ var ledgerArtifactsRelations = drizzleOrm.relations(ledgerArtifacts, ({ one }) =
 var functionsRelations = drizzleOrm.relations(functions, ({ many }) => ({
   tools: many(tools)
 }));
-var agentRelationsRelations = drizzleOrm.relations(agentRelations, ({ one }) => ({
+var subAgentRelationsRelations = 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]
   })
 }));
@@ -1224,22 +1491,22 @@ 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);
-var AgentApiUpdateSchema = 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);
+var SubAgentApiUpdateSchema = createGraphScopedApiUpdateSchema(SubAgentUpdateSchema);
+var AgentRelationSelectSchema = drizzleZod.createSelectSchema(subAgentRelations);
+var AgentRelationInsertSchema = 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();
 var AgentRelationApiSelectSchema = createGraphScopedApiSchema(AgentRelationSelectSchema);
@@ -1249,13 +1516,13 @@ var AgentRelationApiInsertSchema = createGraphScopedApiInsertSchema(
   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"]
   }
 );
 var AgentRelationApiUpdateSchema = createGraphScopedApiUpdateSchema(
@@ -1264,28 +1531,28 @@ var AgentRelationApiUpdateSchema = createGraphScopedApiUpdateSchema(
   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 agent relationships",
+    path: ["targetSubAgentId", "externalSubAgentId"]
   }
 );
 var AgentRelationQuerySchema = 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 ExternalAgentRelationInsertSchema = drizzleZod.createInsertSchema(subAgentRelations).extend({
   id: resourceIdSchema,
   graphId: resourceIdSchema,
-  sourceAgentId: resourceIdSchema,
-  externalAgentId: resourceIdSchema
+  sourceSubAgentId: resourceIdSchema,
+  externalSubAgentId: resourceIdSchema
 });
 var ExternalAgentRelationApiInsertSchema = createApiInsertSchema(
   ExternalAgentRelationInsertSchema
@@ -1419,8 +1686,8 @@ var DataComponentUpdateSchema = DataComponentInsertSchema.partial();
 var DataComponentApiSelectSchema = createApiSchema(DataComponentSelectSchema);
 var DataComponentApiInsertSchema = createApiInsertSchema(DataComponentInsertSchema);
 var DataComponentApiUpdateSchema = createApiUpdateSchema(DataComponentUpdateSchema);
-var AgentDataComponentSelectSchema = drizzleZod.createSelectSchema(agentDataComponents);
-var AgentDataComponentInsertSchema = drizzleZod.createInsertSchema(agentDataComponents);
+var AgentDataComponentSelectSchema = drizzleZod.createSelectSchema(subAgentDataComponents);
+var AgentDataComponentInsertSchema = drizzleZod.createInsertSchema(subAgentDataComponents);
 var AgentDataComponentUpdateSchema = AgentDataComponentInsertSchema.partial();
 var AgentDataComponentApiSelectSchema = createGraphScopedApiSchema(
   AgentDataComponentSelectSchema
@@ -1449,12 +1716,12 @@ var ArtifactComponentApiInsertSchema = ArtifactComponentInsertSchema.omit({
 var ArtifactComponentApiUpdateSchema = createApiUpdateSchema(
   ArtifactComponentUpdateSchema
 );
-var AgentArtifactComponentSelectSchema = drizzleZod.createSelectSchema(agentArtifactComponents);
+var AgentArtifactComponentSelectSchema = drizzleZod.createSelectSchema(subAgentArtifactComponents);
 var AgentArtifactComponentInsertSchema = drizzleZod.createInsertSchema(
-  agentArtifactComponents
+  subAgentArtifactComponents
 ).extend({
   id: resourceIdSchema,
-  agentId: resourceIdSchema,
+  subAgentId: resourceIdSchema,
   artifactComponentId: resourceIdSchema
 });
 var AgentArtifactComponentUpdateSchema = AgentArtifactComponentInsertSchema.partial();
@@ -1482,7 +1749,7 @@ var ExternalAgentApiSelectSchema = createGraphScopedApiSchema(ExternalAgentSelec
 var ExternalAgentApiInsertSchema = createGraphScopedApiInsertSchema(ExternalAgentInsertSchema);
 var ExternalAgentApiUpdateSchema = createGraphScopedApiUpdateSchema(ExternalAgentUpdateSchema);
 var AllAgentSchema = 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);
@@ -1637,10 +1904,10 @@ var ContextConfigApiInsertSchema = createApiInsertSchema(ContextConfigInsertSche
 var ContextConfigApiUpdateSchema = createApiUpdateSchema(ContextConfigUpdateSchema).omit({
   graphId: true
 });
-var AgentToolRelationSelectSchema = drizzleZod.createSelectSchema(agentToolRelations);
-var AgentToolRelationInsertSchema = drizzleZod.createInsertSchema(agentToolRelations).extend({
+var AgentToolRelationSelectSchema = drizzleZod.createSelectSchema(subAgentToolRelations);
+var AgentToolRelationInsertSchema = 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()
@@ -1683,7 +1950,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)
@@ -1692,27 +1959,17 @@ var FullGraphAgentInsertSchema = AgentApiInsertSchema.extend({
   canTransferTo: zodOpenapi.z.array(zodOpenapi.z.string()).optional(),
   canDelegateTo: zodOpenapi.z.array(zodOpenapi.z.string()).optional()
 });
-var FullGraphDefinitionSchema = AgentGraphApiInsertSchema.extend({
-  agents: 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
-  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({
-  agents: zodOpenapi.z.record(
+  subAgents: zodOpenapi.z.record(
     zodOpenapi.z.string(),
     zodOpenapi.z.discriminatedUnion("type", [
       FullGraphAgentInsertSchema,
       ExternalAgentApiInsertSchema.extend({ type: zodOpenapi.z.literal("external") })
     ])
   ),
+  tools: zodOpenapi.z.record(zodOpenapi.z.string(), ToolApiInsertSchema).optional(),
+  // Get tool name/description from toolId
+  functions: zodOpenapi.z.record(zodOpenapi.z.string(), FunctionApiInsertSchema).optional(),
   contextConfig: zodOpenapi.z.optional(ContextConfigApiInsertSchema),
   statusUpdates: zodOpenapi.z.optional(StatusUpdateSchema),
   models: ModelSchema.optional(),
@@ -1784,72 +2041,46 @@ var HeadersScopeSchema = zodOpenapi.z.object({
     example: "graph_789"
   })
 });
+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: zodOpenapi.z.string().openapi({
-    description: "Tenant identifier",
-    example: "tenant_123"
-  })
+  tenantId: TenantId
 }).openapi("TenantParams");
-var TenantProjectParamsSchema = 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");
-var TenantProjectGraphParamsSchema = 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");
-var TenantProjectGraphIdParamsSchema = 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"
-  }),
+var TenantIdParamsSchema = TenantParamsSchema.extend({
   id: resourceIdSchema
-}).openapi("TenantProjectGraphIdParams");
-var TenantProjectIdParamsSchema = 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");
+var TenantProjectIdParamsSchema = TenantProjectParamsSchema.extend({
   id: resourceIdSchema
 }).openapi("TenantProjectIdParams");
-var TenantIdParamsSchema = zodOpenapi.z.object({
-  tenantId: zodOpenapi.z.string().openapi({
-    description: "Tenant identifier",
-    example: "tenant_123"
-  }),
+var TenantProjectGraphParamsSchema = TenantProjectParamsSchema.extend({
+  graphId: GraphId
+}).openapi("TenantProjectGraphParams");
+var TenantProjectGraphIdParamsSchema = TenantProjectGraphParamsSchema.extend({
   id: resourceIdSchema
-}).openapi("TenantIdParams");
-var IdParamsSchema = zodOpenapi.z.object({
+}).openapi("TenantProjectGraphIdParams");
+var TenantProjectGraphSubAgentParamsSchema = TenantProjectGraphParamsSchema.extend({
+  subAgentId: SubAgentId
+}).openapi("TenantProjectGraphSubAgentParams");
+var TenantProjectGraphSubAgentIdParamsSchema = TenantProjectGraphSubAgentParamsSchema.extend({
   id: resourceIdSchema
-}).openapi("IdParams");
+}).openapi("TenantProjectGraphSubAgentIdParams");
 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)
@@ -2567,263 +2798,623 @@ function createInMemoryDatabaseClient() {
   const db = createDatabaseClient({ url: ":memory:" });
   return db;
 }
-var getAgentRelationById = (db) => async (params) => {
-  return db.query.agentRelations.findFirst({
-    where: drizzleOrm.and(
-      drizzleOrm.eq(agentRelations.tenantId, params.scopes.tenantId),
-      drizzleOrm.eq(agentRelations.projectId, params.scopes.projectId),
-      drizzleOrm.eq(agentRelations.graphId, params.scopes.graphId),
-      drizzleOrm.eq(agentRelations.id, params.relationId)
-    )
-  });
-};
-var listAgentRelations = (db) => async (params) => {
-  const page = params.pagination?.page || 1;
-  const limit = Math.min(params.pagination?.limit || 10, 100);
-  const offset = (page - 1) * limit;
-  const whereClause = drizzleOrm.and(
-    drizzleOrm.eq(agentRelations.tenantId, params.scopes.tenantId),
-    drizzleOrm.eq(agentRelations.projectId, params.scopes.projectId),
-    drizzleOrm.eq(agentRelations.graphId, params.scopes.graphId)
-  );
-  const [data, totalResult] = await Promise.all([
-    db.select().from(agentRelations).where(whereClause).limit(limit).offset(offset).orderBy(drizzleOrm.desc(agentRelations.createdAt)),
-    db.select({ count: drizzleOrm.count() }).from(agentRelations).where(whereClause)
-  ]);
-  const total = totalResult[0]?.count || 0;
-  const pages = Math.ceil(total / limit);
-  return { data, pagination: { page, limit, total, pages } };
-};
-var getAgentRelations = (db) => async (params) => {
-  return await db.query.agentRelations.findMany({
+var getContextConfigById = (db) => async (params) => {
+  return await db.query.contextConfigs.findFirst({
     where: drizzleOrm.and(
-      drizzleOrm.eq(agentRelations.tenantId, params.scopes.tenantId),
-      drizzleOrm.eq(agentRelations.projectId, params.scopes.projectId),
-      drizzleOrm.eq(agentRelations.graphId, params.scopes.graphId),
-      drizzleOrm.eq(agentRelations.sourceAgentId, params.scopes.agentId)
+      drizzleOrm.eq(contextConfigs.tenantId, params.scopes.tenantId),
+      drizzleOrm.eq(contextConfigs.projectId, params.scopes.projectId),
+      drizzleOrm.eq(contextConfigs.graphId, params.scopes.graphId),
+      drizzleOrm.eq(contextConfigs.id, params.id)
     )
   });
 };
-var getAgentRelationsByGraph = (db) => async (params) => {
-  return await db.query.agentRelations.findMany({
+var listContextConfigs = (db) => async (params) => {
+  return await db.query.contextConfigs.findMany({
     where: drizzleOrm.and(
-      drizzleOrm.eq(agentRelations.tenantId, params.scopes.tenantId),
-      drizzleOrm.eq(agentRelations.projectId, params.scopes.projectId),
-      drizzleOrm.eq(agentRelations.graphId, params.scopes.graphId)
-    )
+      drizzleOrm.eq(contextConfigs.tenantId, params.scopes.tenantId),
+      drizzleOrm.eq(contextConfigs.projectId, params.scopes.projectId),
+      drizzleOrm.eq(contextConfigs.graphId, params.scopes.graphId)
+    ),
+    orderBy: [drizzleOrm.desc(contextConfigs.createdAt)]
   });
 };
-var getAgentRelationsBySource = (db) => async (params) => {
-  const page = params.pagination?.page || 1;
-  const limit = Math.min(params.pagination?.limit || 10, 100);
-  const offset = (page - 1) * limit;
-  const whereClause = drizzleOrm.and(
-    drizzleOrm.eq(agentRelations.tenantId, params.scopes.tenantId),
-    drizzleOrm.eq(agentRelations.projectId, params.scopes.projectId),
-    drizzleOrm.eq(agentRelations.graphId, params.scopes.graphId),
-    drizzleOrm.eq(agentRelations.sourceAgentId, params.sourceAgentId)
-  );
-  const [data, totalResult] = await Promise.all([
-    db.select().from(agentRelations).where(whereClause).limit(limit).offset(offset).orderBy(drizzleOrm.desc(agentRelations.createdAt)),
-    db.select({ count: drizzleOrm.count() }).from(agentRelations).where(whereClause)
-  ]);
-  const total = totalResult[0]?.count || 0;
-  const pages = Math.ceil(total / limit);
-  return {
-    data,
-    pagination: { page, limit, total, pages }
-  };
-};
-var getAgentRelationsByTarget = (db) => async (params) => {
-  const page = params.pagination?.page || 1;
-  const limit = Math.min(params.pagination?.limit || 10, 100);
-  const offset = (page - 1) * limit;
-  const whereClause = drizzleOrm.and(
-    drizzleOrm.eq(agentRelations.tenantId, params.scopes.tenantId),
-    drizzleOrm.eq(agentRelations.projectId, params.scopes.projectId),
-    drizzleOrm.eq(agentRelations.graphId, params.scopes.graphId),
-    drizzleOrm.eq(agentRelations.targetAgentId, params.targetAgentId)
-  );
-  const [data, totalResult] = await Promise.all([
-    db.select().from(agentRelations).where(whereClause).limit(limit).offset(offset).orderBy(drizzleOrm.desc(agentRelations.createdAt)),
-    db.select({ count: drizzleOrm.count() }).from(agentRelations).where(whereClause)
-  ]);
-  const total = totalResult[0]?.count || 0;
-  const pages = Math.ceil(total / limit);
-  return {
-    data,
-    pagination: { page, limit, total, pages }
-  };
-};
-var getExternalAgentRelations = (db) => async (params) => {
+var listContextConfigsPaginated = (db) => async (params) => {
   const page = params.pagination?.page || 1;
   const limit = Math.min(params.pagination?.limit || 10, 100);
   const offset = (page - 1) * limit;
   const whereClause = drizzleOrm.and(
-    drizzleOrm.eq(agentRelations.tenantId, params.scopes.tenantId),
-    drizzleOrm.eq(agentRelations.projectId, params.scopes.projectId),
-    drizzleOrm.eq(agentRelations.graphId, params.scopes.graphId),
-    drizzleOrm.eq(agentRelations.externalAgentId, params.externalAgentId)
+    drizzleOrm.eq(contextConfigs.tenantId, params.scopes.tenantId),
+    drizzleOrm.eq(contextConfigs.projectId, params.scopes.projectId),
+    drizzleOrm.eq(contextConfigs.graphId, params.scopes.graphId)
   );
-  const [data, totalResult] = await Promise.all([
-    db.select().from(agentRelations).where(whereClause).limit(limit).offset(offset).orderBy(drizzleOrm.desc(agentRelations.createdAt)),
-    db.select({ count: drizzleOrm.count() }).from(agentRelations).where(whereClause)
+  const [contextConfigList, totalResult] = await Promise.all([
+    db.select().from(contextConfigs).where(whereClause).limit(limit).offset(offset).orderBy(drizzleOrm.desc(contextConfigs.createdAt)),
+    db.select({ count: drizzleOrm.sql`COUNT(*)` }).from(contextConfigs).where(whereClause)
   ]);
-  const total = totalResult[0]?.count || 0;
+  const total = Number(totalResult[0]?.count || 0);
   const pages = Math.ceil(total / limit);
   return {
-    data,
-    pagination: { page, limit, total, pages }
-  };
-};
-var getRelatedAgentsForGraph = (db) => async (params) => {
-  const internalRelations = await db.select({
-    id: agents.id,
-    name: agents.name,
-    description: agents.description,
-    relationType: agentRelations.relationType
-  }).from(agentRelations).innerJoin(
-    agents,
-    drizzleOrm.and(
-      drizzleOrm.eq(agentRelations.targetAgentId, agents.id),
-      drizzleOrm.eq(agentRelations.tenantId, agents.tenantId),
-      drizzleOrm.eq(agentRelations.projectId, agents.projectId),
-      drizzleOrm.eq(agentRelations.graphId, agents.graphId)
-    )
-  ).where(
-    drizzleOrm.and(
-      drizzleOrm.eq(agentRelations.tenantId, params.scopes.tenantId),
-      drizzleOrm.eq(agentRelations.projectId, params.scopes.projectId),
-      drizzleOrm.eq(agentRelations.graphId, params.scopes.graphId),
-      drizzleOrm.eq(agentRelations.sourceAgentId, params.agentId),
-      drizzleOrm.isNotNull(agentRelations.targetAgentId)
-    )
-  );
-  const externalRelations = await db.select({
-    id: agentRelations.id,
-    relationType: agentRelations.relationType,
-    externalAgent: {
-      id: externalAgents.id,
-      name: externalAgents.name,
-      description: externalAgents.description,
-      baseUrl: externalAgents.baseUrl
+    data: contextConfigList,
+    pagination: {
+      page,
+      limit,
+      total,
+      pages
     }
-  }).from(agentRelations).innerJoin(
-    externalAgents,
-    drizzleOrm.and(
-      drizzleOrm.eq(agentRelations.externalAgentId, externalAgents.id),
-      drizzleOrm.eq(agentRelations.tenantId, externalAgents.tenantId),
-      drizzleOrm.eq(agentRelations.projectId, externalAgents.projectId),
-      drizzleOrm.eq(agentRelations.graphId, externalAgents.graphId)
-    )
-  ).where(
-    drizzleOrm.and(
-      drizzleOrm.eq(agentRelations.tenantId, params.scopes.tenantId),
-      drizzleOrm.eq(agentRelations.projectId, params.scopes.projectId),
-      drizzleOrm.eq(agentRelations.graphId, params.scopes.graphId),
-      drizzleOrm.eq(agentRelations.sourceAgentId, params.agentId),
-      drizzleOrm.isNotNull(agentRelations.externalAgentId)
-    )
-  );
-  return {
-    internalRelations,
-    externalRelations
   };
 };
-var createAgentRelation = (db) => async (params) => {
-  const hasTargetAgent = params.targetAgentId != null;
-  const hasExternalAgent = params.externalAgentId != null;
-  if (hasTargetAgent && hasExternalAgent) {
-    throw new Error("Cannot specify both targetAgentId and externalAgentId");
-  }
-  if (!hasTargetAgent && !hasExternalAgent) {
-    throw new Error("Must specify either targetAgentId or externalAgentId");
+var createContextConfig = (db) => async (params) => {
+  const id = params.id || nanoid.nanoid();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  let contextVariables = params.contextVariables;
+  if (contextVariables !== void 0 && contextVariables !== null && typeof contextVariables === "object" && Object.keys(contextVariables).length === 0) {
+    contextVariables = null;
   }
-  const relation = await db.insert(agentRelations).values({
-    ...params
+  const contextConfig2 = await db.insert(contextConfigs).values({
+    id,
+    tenantId: params.tenantId,
+    projectId: params.projectId,
+    graphId: params.graphId,
+    headersSchema: params.headersSchema ?? null,
+    contextVariables: contextVariables ?? null,
+    createdAt: now,
+    updatedAt: now
   }).returning();
-  return relation[0];
+  return contextConfig2[0];
 };
-var getAgentRelationByParams = (db) => async (params) => {
-  const whereConditions = [
-    drizzleOrm.eq(agentRelations.tenantId, params.scopes.tenantId),
-    drizzleOrm.eq(agentRelations.projectId, params.scopes.projectId),
-    drizzleOrm.eq(agentRelations.graphId, params.scopes.graphId),
-    drizzleOrm.eq(agentRelations.sourceAgentId, params.sourceAgentId),
-    drizzleOrm.eq(agentRelations.relationType, params.relationType)
-  ];
-  if (params.targetAgentId) {
-    whereConditions.push(drizzleOrm.eq(agentRelations.targetAgentId, params.targetAgentId));
-  }
-  if (params.externalAgentId) {
-    whereConditions.push(drizzleOrm.eq(agentRelations.externalAgentId, params.externalAgentId));
+var updateContextConfig = (db) => async (params) => {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const processedData = { ...params.data };
+  if ("contextVariables" in params.data) {
+    if (params.data.contextVariables === null || typeof params.data.contextVariables === "object" && params.data.contextVariables !== null && Object.keys(params.data.contextVariables).length === 0) {
+      processedData.contextVariables = null;
+    }
   }
-  return db.query.agentRelations.findFirst({
-    where: drizzleOrm.and(...whereConditions)
-  });
-};
-var upsertAgentRelation = (db) => async (params) => {
-  const existing = await getAgentRelationByParams(db)({
-    scopes: { tenantId: params.tenantId, projectId: params.projectId, graphId: params.graphId },
-    sourceAgentId: params.sourceAgentId,
-    targetAgentId: params.targetAgentId,
-    externalAgentId: params.externalAgentId,
-    relationType: params.relationType ?? ""
-  });
-  if (!existing) {
-    return await createAgentRelation(db)(params);
+  if ("headersSchema" in params.data && params.data.headersSchema === null) {
+    processedData.headersSchema = null;
   }
-  return existing;
-};
-var createExternalAgentRelation = (db) => async (params) => {
-  return await createAgentRelation(db)({
-    ...params,
-    targetAgentId: void 0
-  });
-};
-var updateAgentRelation = (db) => async (params) => {
-  const updateData = {
-    ...params.data,
-    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-  };
-  const relation = await db.update(agentRelations).set(updateData).where(
+  const updated = await db.update(contextConfigs).set({
+    ...processedData,
+    updatedAt: now
+  }).where(
     drizzleOrm.and(
-      drizzleOrm.eq(agentRelations.tenantId, params.scopes.tenantId),
-      drizzleOrm.eq(agentRelations.projectId, params.scopes.projectId),
-      drizzleOrm.eq(agentRelations.graphId, params.scopes.graphId),
-      drizzleOrm.eq(agentRelations.id, params.relationId)
+      drizzleOrm.eq(contextConfigs.tenantId, params.scopes.tenantId),
+      drizzleOrm.eq(contextConfigs.projectId, params.scopes.projectId),
+      drizzleOrm.eq(contextConfigs.graphId, params.scopes.graphId),
+      drizzleOrm.eq(contextConfigs.id, params.id)
     )
   ).returning();
-  return relation[0];
+  return updated[0];
 };
-var deleteAgentRelation = (db) => async (params) => {
-  const result = await db.delete(agentRelations).where(
-    drizzleOrm.and(
-      drizzleOrm.eq(agentRelations.tenantId, params.scopes.tenantId),
-      drizzleOrm.eq(agentRelations.projectId, params.scopes.projectId),
-      drizzleOrm.eq(agentRelations.graphId, params.scopes.graphId),
-      drizzleOrm.eq(agentRelations.id, params.relationId)
-    )
-  );
+var deleteContextConfig = (db) => async (params) => {
+  try {
+    const result = await db.delete(contextConfigs).where(
+      drizzleOrm.and(
+        drizzleOrm.eq(contextConfigs.tenantId, params.scopes.tenantId),
+        drizzleOrm.eq(contextConfigs.projectId, params.scopes.projectId),
+        drizzleOrm.eq(contextConfigs.graphId, params.scopes.graphId),
+        drizzleOrm.eq(contextConfigs.id, params.id)
+      )
+    ).returning();
+    return result.length > 0;
+  } catch (error) {
+    console.error("Error deleting context config:", error);
+    return false;
+  }
+};
+var hasContextConfig = (db) => async (params) => {
+  const contextConfig2 = await getContextConfigById(db)(params);
+  return contextConfig2 !== null;
+};
+var countContextConfigs = (db) => async (params) => {
+  const result = await db.select({ count: drizzleOrm.count() }).from(contextConfigs).where(
+    drizzleOrm.and(
+      drizzleOrm.eq(contextConfigs.tenantId, params.scopes.tenantId),
+      drizzleOrm.eq(contextConfigs.projectId, params.scopes.projectId),
+      drizzleOrm.eq(contextConfigs.graphId, params.scopes.graphId)
+    )
+  );
+  const total = result[0]?.count || 0;
+  return typeof total === "string" ? Number.parseInt(total, 10) : total;
+};
+var upsertContextConfig = (db) => async (params) => {
+  const scopes = {
+    tenantId: params.data.tenantId,
+    projectId: params.data.projectId,
+    graphId: params.data.graphId
+  };
+  if (params.data.id) {
+    const existing = await getContextConfigById(db)({
+      scopes,
+      id: params.data.id
+    });
+    if (existing) {
+      return await updateContextConfig(db)({
+        scopes,
+        id: params.data.id,
+        data: {
+          headersSchema: params.data.headersSchema,
+          contextVariables: params.data.contextVariables
+        }
+      });
+    }
+  }
+  return await createContextConfig(db)(params.data);
+};
+var createExternalAgent = (db) => async (params) => {
+  const agent = await db.insert(externalAgents).values(params).returning();
+  return agent[0];
+};
+var getExternalAgent = (db) => async (params) => {
+  const result = await db.query.externalAgents.findFirst({
+    where: drizzleOrm.and(
+      drizzleOrm.eq(externalAgents.tenantId, params.scopes.tenantId),
+      drizzleOrm.eq(externalAgents.projectId, params.scopes.projectId),
+      drizzleOrm.eq(externalAgents.graphId, params.scopes.graphId),
+      drizzleOrm.eq(externalAgents.id, params.subAgentId)
+    )
+  });
+  return result || null;
+};
+var getExternalAgentByUrl = (db) => async (params) => {
+  const result = await db.query.externalAgents.findFirst({
+    where: drizzleOrm.and(
+      drizzleOrm.eq(externalAgents.tenantId, params.scopes.tenantId),
+      drizzleOrm.eq(externalAgents.projectId, params.scopes.projectId),
+      drizzleOrm.eq(externalAgents.graphId, params.scopes.graphId),
+      drizzleOrm.eq(externalAgents.baseUrl, params.baseUrl)
+    )
+  });
+  return result || null;
+};
+var listExternalAgents = (db) => async (params) => {
+  return await db.query.externalAgents.findMany({
+    where: drizzleOrm.and(
+      drizzleOrm.eq(externalAgents.tenantId, params.scopes.tenantId),
+      drizzleOrm.eq(externalAgents.projectId, params.scopes.projectId),
+      drizzleOrm.eq(externalAgents.graphId, params.scopes.graphId)
+    ),
+    orderBy: [drizzleOrm.asc(externalAgents.name)]
+  });
+};
+var listExternalAgentsPaginated = (db) => async (params) => {
+  const page = params.pagination?.page || 1;
+  const limit = Math.min(params.pagination?.limit || 10, 100);
+  const offset = (page - 1) * limit;
+  const [data, totalResult] = await Promise.all([
+    db.select().from(externalAgents).where(
+      drizzleOrm.and(
+        drizzleOrm.eq(externalAgents.tenantId, params.scopes.tenantId),
+        drizzleOrm.eq(externalAgents.projectId, params.scopes.projectId),
+        drizzleOrm.eq(externalAgents.graphId, params.scopes.graphId)
+      )
+    ).limit(limit).offset(offset).orderBy(drizzleOrm.desc(externalAgents.createdAt)),
+    db.select({ count: drizzleOrm.count() }).from(externalAgents).where(
+      drizzleOrm.and(
+        drizzleOrm.eq(externalAgents.tenantId, params.scopes.tenantId),
+        drizzleOrm.eq(externalAgents.projectId, params.scopes.projectId),
+        drizzleOrm.eq(externalAgents.graphId, params.scopes.graphId)
+      )
+    )
+  ]);
+  const total = typeof totalResult[0]?.count === "string" ? parseInt(totalResult[0].count, 10) : totalResult[0]?.count || 0;
+  const pages = Math.ceil(total / limit);
+  return {
+    data,
+    pagination: { page, limit, total, pages }
+  };
+};
+var updateExternalAgent = (db) => async (params) => {
+  const updateData = {
+    ...params.data,
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  if (Object.keys(updateData).length === 1) {
+    throw new Error("No fields to update");
+  }
+  if (updateData.headers !== void 0 && (updateData.headers === null || Object.keys(updateData.headers || {}).length === 0)) {
+    updateData.headers = null;
+  }
+  if (updateData.credentialReferenceId === void 0) {
+    updateData.credentialReferenceId = null;
+  }
+  const result = await db.update(externalAgents).set(updateData).where(
+    drizzleOrm.and(
+      drizzleOrm.eq(externalAgents.tenantId, params.scopes.tenantId),
+      drizzleOrm.eq(externalAgents.projectId, params.scopes.projectId),
+      drizzleOrm.eq(externalAgents.graphId, params.scopes.graphId),
+      drizzleOrm.eq(externalAgents.id, params.subAgentId)
+    )
+  ).returning();
+  return result[0] || null;
+};
+var upsertExternalAgent = (db) => async (params) => {
+  const scopes = {
+    tenantId: params.data.tenantId,
+    projectId: params.data.projectId,
+    graphId: params.data.graphId
+  };
+  const existing = await getExternalAgent(db)({
+    scopes,
+    subAgentId: params.data.id
+  });
+  if (existing) {
+    const updated = await updateExternalAgent(db)({
+      scopes,
+      subAgentId: params.data.id,
+      data: {
+        name: params.data.name,
+        description: params.data.description,
+        baseUrl: params.data.baseUrl,
+        credentialReferenceId: params.data.credentialReferenceId,
+        headers: params.data.headers
+      }
+    });
+    if (!updated) {
+      throw new Error("Failed to update external agent - no rows affected");
+    }
+    return updated;
+  } else {
+    return await createExternalAgent(db)(params.data);
+  }
+};
+var deleteExternalAgent = (db) => async (params) => {
+  try {
+    const result = await db.delete(externalAgents).where(
+      drizzleOrm.and(
+        drizzleOrm.eq(externalAgents.tenantId, params.scopes.tenantId),
+        drizzleOrm.eq(externalAgents.projectId, params.scopes.projectId),
+        drizzleOrm.eq(externalAgents.graphId, params.scopes.graphId),
+        drizzleOrm.eq(externalAgents.id, params.subAgentId)
+      )
+    ).returning();
+    return result.length > 0;
+  } catch (error) {
+    console.error("Error deleting external agent:", error);
+    return false;
+  }
+};
+var externalAgentExists = (db) => async (params) => {
+  const agent = await getExternalAgent(db)(params);
+  return agent !== null;
+};
+var externalAgentUrlExists = (db) => async (params) => {
+  const agent = await getExternalAgentByUrl(db)(params);
+  return agent !== null;
+};
+var countExternalAgents = (db) => async (params) => {
+  const result = await db.select({ count: drizzleOrm.count() }).from(externalAgents).where(
+    drizzleOrm.and(
+      drizzleOrm.eq(externalAgents.tenantId, params.scopes.tenantId),
+      drizzleOrm.eq(externalAgents.projectId, params.scopes.projectId),
+      drizzleOrm.eq(externalAgents.graphId, params.scopes.graphId)
+    )
+  );
+  const countValue = result[0]?.count;
+  return typeof countValue === "string" ? parseInt(countValue, 10) : countValue || 0;
+};
+var upsertFunction = (db) => async (params) => {
+  const { data, scopes } = params;
+  const { tenantId, projectId } = scopes;
+  const existingFunction = await db.select().from(functions).where(
+    drizzleOrm.and(
+      drizzleOrm.eq(functions.tenantId, tenantId),
+      drizzleOrm.eq(functions.projectId, projectId),
+      drizzleOrm.eq(functions.id, data.id)
+    )
+  ).limit(1);
+  if (existingFunction.length > 0) {
+    await db.update(functions).set({
+      inputSchema: data.inputSchema,
+      executeCode: data.executeCode,
+      dependencies: data.dependencies,
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    }).where(
+      drizzleOrm.and(
+        drizzleOrm.eq(functions.tenantId, tenantId),
+        drizzleOrm.eq(functions.projectId, projectId),
+        drizzleOrm.eq(functions.id, data.id)
+      )
+    );
+  } else {
+    await db.insert(functions).values({
+      tenantId,
+      projectId,
+      id: data.id,
+      inputSchema: data.inputSchema,
+      executeCode: data.executeCode,
+      dependencies: data.dependencies,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  }
+};
+var getFunction = (db) => async (params) => {
+  const { functionId, scopes } = params;
+  const { tenantId, projectId } = scopes;
+  const result = await db.select().from(functions).where(
+    drizzleOrm.and(
+      drizzleOrm.eq(functions.tenantId, tenantId),
+      drizzleOrm.eq(functions.projectId, projectId),
+      drizzleOrm.eq(functions.id, functionId)
+    )
+  ).limit(1);
+  return result[0] || null;
+};
+var listFunctions = (db) => async (params) => {
+  const { scopes } = params;
+  const { tenantId, projectId } = scopes;
+  const result = await db.select().from(functions).where(drizzleOrm.and(drizzleOrm.eq(functions.tenantId, tenantId), drizzleOrm.eq(functions.projectId, projectId)));
+  return result;
+};
+var deleteFunction = (db) => async (params) => {
+  const { functionId, scopes } = params;
+  const { tenantId, projectId } = scopes;
+  await db.delete(functions).where(
+    drizzleOrm.and(
+      drizzleOrm.eq(functions.tenantId, tenantId),
+      drizzleOrm.eq(functions.projectId, projectId),
+      drizzleOrm.eq(functions.id, functionId)
+    )
+  );
+};
+var getAgentRelationById = (db) => async (params) => {
+  return db.query.subAgentRelations.findFirst({
+    where: drizzleOrm.and(
+      drizzleOrm.eq(subAgentRelations.tenantId, params.scopes.tenantId),
+      drizzleOrm.eq(subAgentRelations.projectId, params.scopes.projectId),
+      drizzleOrm.eq(subAgentRelations.graphId, params.scopes.graphId),
+      drizzleOrm.eq(subAgentRelations.id, params.relationId)
+    )
+  });
+};
+var listAgentRelations = (db) => async (params) => {
+  const page = params.pagination?.page || 1;
+  const limit = Math.min(params.pagination?.limit || 10, 100);
+  const offset = (page - 1) * limit;
+  const whereClause = drizzleOrm.and(
+    drizzleOrm.eq(subAgentRelations.tenantId, params.scopes.tenantId),
+    drizzleOrm.eq(subAgentRelations.projectId, params.scopes.projectId),
+    drizzleOrm.eq(subAgentRelations.graphId, params.scopes.graphId)
+  );
+  const [data, totalResult] = await Promise.all([
+    db.select().from(subAgentRelations).where(whereClause).limit(limit).offset(offset).orderBy(drizzleOrm.desc(subAgentRelations.createdAt)),
+    db.select({ count: drizzleOrm.count() }).from(subAgentRelations).where(whereClause)
+  ]);
+  const total = totalResult[0]?.count || 0;
+  const pages = Math.ceil(total / limit);
+  return { data, pagination: { page, limit, total, pages } };
+};
+var getAgentRelations = (db) => async (params) => {
+  return await db.query.subAgentRelations.findMany({
+    where: drizzleOrm.and(
+      drizzleOrm.eq(subAgentRelations.tenantId, params.scopes.tenantId),
+      drizzleOrm.eq(subAgentRelations.projectId, params.scopes.projectId),
+      drizzleOrm.eq(subAgentRelations.graphId, params.scopes.graphId),
+      drizzleOrm.eq(subAgentRelations.sourceSubAgentId, params.scopes.subAgentId)
+    )
+  });
+};
+var getAgentRelationsByGraph = (db) => async (params) => {
+  return await db.query.subAgentRelations.findMany({
+    where: drizzleOrm.and(
+      drizzleOrm.eq(subAgentRelations.tenantId, params.scopes.tenantId),
+      drizzleOrm.eq(subAgentRelations.projectId, params.scopes.projectId),
+      drizzleOrm.eq(subAgentRelations.graphId, params.scopes.graphId)
+    )
+  });
+};
+var getAgentRelationsBySource = (db) => async (params) => {
+  const page = params.pagination?.page || 1;
+  const limit = Math.min(params.pagination?.limit || 10, 100);
+  const offset = (page - 1) * limit;
+  const whereClause = drizzleOrm.and(
+    drizzleOrm.eq(subAgentRelations.tenantId, params.scopes.tenantId),
+    drizzleOrm.eq(subAgentRelations.projectId, params.scopes.projectId),
+    drizzleOrm.eq(subAgentRelations.graphId, params.scopes.graphId),
+    drizzleOrm.eq(subAgentRelations.sourceSubAgentId, params.sourceSubAgentId)
+  );
+  const [data, totalResult] = await Promise.all([
+    db.select().from(subAgentRelations).where(whereClause).limit(limit).offset(offset).orderBy(drizzleOrm.desc(subAgentRelations.createdAt)),
+    db.select({ count: drizzleOrm.count() }).from(subAgentRelations).where(whereClause)
+  ]);
+  const total = totalResult[0]?.count || 0;
+  const pages = Math.ceil(total / limit);
+  return {
+    data,
+    pagination: { page, limit, total, pages }
+  };
+};
+var getAgentRelationsByTarget = (db) => async (params) => {
+  const page = params.pagination?.page || 1;
+  const limit = Math.min(params.pagination?.limit || 10, 100);
+  const offset = (page - 1) * limit;
+  const whereClause = drizzleOrm.and(
+    drizzleOrm.eq(subAgentRelations.tenantId, params.scopes.tenantId),
+    drizzleOrm.eq(subAgentRelations.projectId, params.scopes.projectId),
+    drizzleOrm.eq(subAgentRelations.graphId, params.scopes.graphId),
+    drizzleOrm.eq(subAgentRelations.targetSubAgentId, params.targetSubAgentId)
+  );
+  const [data, totalResult] = await Promise.all([
+    db.select().from(subAgentRelations).where(whereClause).limit(limit).offset(offset).orderBy(drizzleOrm.desc(subAgentRelations.createdAt)),
+    db.select({ count: drizzleOrm.count() }).from(subAgentRelations).where(whereClause)
+  ]);
+  const total = totalResult[0]?.count || 0;
+  const pages = Math.ceil(total / limit);
+  return {
+    data,
+    pagination: { page, limit, total, pages }
+  };
+};
+var getExternalAgentRelations = (db) => async (params) => {
+  const page = params.pagination?.page || 1;
+  const limit = Math.min(params.pagination?.limit || 10, 100);
+  const offset = (page - 1) * limit;
+  const whereClause = drizzleOrm.and(
+    drizzleOrm.eq(subAgentRelations.tenantId, params.scopes.tenantId),
+    drizzleOrm.eq(subAgentRelations.projectId, params.scopes.projectId),
+    drizzleOrm.eq(subAgentRelations.graphId, params.scopes.graphId),
+    drizzleOrm.eq(subAgentRelations.externalSubAgentId, params.externalSubAgentId)
+  );
+  const [data, totalResult] = await Promise.all([
+    db.select().from(subAgentRelations).where(whereClause).limit(limit).offset(offset).orderBy(drizzleOrm.desc(subAgentRelations.createdAt)),
+    db.select({ count: drizzleOrm.count() }).from(subAgentRelations).where(whereClause)
+  ]);
+  const total = totalResult[0]?.count || 0;
+  const pages = Math.ceil(total / limit);
+  return {
+    data,
+    pagination: { page, limit, total, pages }
+  };
+};
+var getRelatedAgentsForGraph = (db) => async (params) => {
+  const internalRelations = await db.select({
+    id: subAgents.id,
+    name: subAgents.name,
+    description: subAgents.description,
+    relationType: subAgentRelations.relationType
+  }).from(subAgentRelations).innerJoin(
+    subAgents,
+    drizzleOrm.and(
+      drizzleOrm.eq(subAgentRelations.targetSubAgentId, subAgents.id),
+      drizzleOrm.eq(subAgentRelations.tenantId, subAgents.tenantId),
+      drizzleOrm.eq(subAgentRelations.projectId, subAgents.projectId),
+      drizzleOrm.eq(subAgentRelations.graphId, subAgents.graphId)
+    )
+  ).where(
+    drizzleOrm.and(
+      drizzleOrm.eq(subAgentRelations.tenantId, params.scopes.tenantId),
+      drizzleOrm.eq(subAgentRelations.projectId, params.scopes.projectId),
+      drizzleOrm.eq(subAgentRelations.graphId, params.scopes.graphId),
+      drizzleOrm.eq(subAgentRelations.sourceSubAgentId, params.subAgentId),
+      drizzleOrm.isNotNull(subAgentRelations.targetSubAgentId)
+    )
+  );
+  const externalRelations = await db.select({
+    id: subAgentRelations.id,
+    relationType: subAgentRelations.relationType,
+    externalAgent: {
+      id: externalAgents.id,
+      name: externalAgents.name,
+      description: externalAgents.description,
+      baseUrl: externalAgents.baseUrl
+    }
+  }).from(subAgentRelations).innerJoin(
+    externalAgents,
+    drizzleOrm.and(
+      drizzleOrm.eq(subAgentRelations.externalSubAgentId, externalAgents.id),
+      drizzleOrm.eq(subAgentRelations.tenantId, externalAgents.tenantId),
+      drizzleOrm.eq(subAgentRelations.projectId, externalAgents.projectId),
+      drizzleOrm.eq(subAgentRelations.graphId, externalAgents.graphId)
+    )
+  ).where(
+    drizzleOrm.and(
+      drizzleOrm.eq(subAgentRelations.tenantId, params.scopes.tenantId),
+      drizzleOrm.eq(subAgentRelations.projectId, params.scopes.projectId),
+      drizzleOrm.eq(subAgentRelations.graphId, params.scopes.graphId),
+      drizzleOrm.eq(subAgentRelations.sourceSubAgentId, params.subAgentId),
+      drizzleOrm.isNotNull(subAgentRelations.externalSubAgentId)
+    )
+  );
+  return {
+    internalRelations,
+    externalRelations
+  };
+};
+var createSubAgentRelation = (db) => async (params) => {
+  const hasTargetAgent = params.targetSubAgentId != null;
+  const hasExternalAgent = params.externalSubAgentId != null;
+  if (hasTargetAgent && hasExternalAgent) {
+    throw new Error("Cannot specify both targetSubAgentId and externalSubAgentId");
+  }
+  if (!hasTargetAgent && !hasExternalAgent) {
+    throw new Error("Must specify either targetSubAgentId or externalSubAgentId");
+  }
+  const relation = await db.insert(subAgentRelations).values({
+    ...params
+  }).returning();
+  return relation[0];
+};
+var getAgentRelationByParams = (db) => async (params) => {
+  const whereConditions = [
+    drizzleOrm.eq(subAgentRelations.tenantId, params.scopes.tenantId),
+    drizzleOrm.eq(subAgentRelations.projectId, params.scopes.projectId),
+    drizzleOrm.eq(subAgentRelations.graphId, params.scopes.graphId),
+    drizzleOrm.eq(subAgentRelations.sourceSubAgentId, params.sourceSubAgentId),
+    drizzleOrm.eq(subAgentRelations.relationType, params.relationType)
+  ];
+  if (params.targetSubAgentId) {
+    whereConditions.push(drizzleOrm.eq(subAgentRelations.targetSubAgentId, params.targetSubAgentId));
+  }
+  if (params.externalSubAgentId) {
+    whereConditions.push(drizzleOrm.eq(subAgentRelations.externalSubAgentId, params.externalSubAgentId));
+  }
+  return db.query.subAgentRelations.findFirst({
+    where: drizzleOrm.and(...whereConditions)
+  });
+};
+var upsertAgentRelation = (db) => async (params) => {
+  const existing = await getAgentRelationByParams(db)({
+    scopes: { tenantId: params.tenantId, projectId: params.projectId, graphId: params.graphId },
+    sourceSubAgentId: params.sourceSubAgentId,
+    targetSubAgentId: params.targetSubAgentId,
+    externalSubAgentId: params.externalSubAgentId,
+    relationType: params.relationType ?? ""
+  });
+  if (!existing) {
+    return await createSubAgentRelation(db)(params);
+  }
+  return existing;
+};
+var createExternalAgentRelation = (db) => async (params) => {
+  return await createSubAgentRelation(db)({
+    ...params,
+    targetSubAgentId: void 0
+  });
+};
+var updateAgentRelation = (db) => async (params) => {
+  const updateData = {
+    ...params.data,
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  const relation = await db.update(subAgentRelations).set(updateData).where(
+    drizzleOrm.and(
+      drizzleOrm.eq(subAgentRelations.tenantId, params.scopes.tenantId),
+      drizzleOrm.eq(subAgentRelations.projectId, params.scopes.projectId),
+      drizzleOrm.eq(subAgentRelations.graphId, params.scopes.graphId),
+      drizzleOrm.eq(subAgentRelations.id, params.relationId)
+    )
+  ).returning();
+  return relation[0];
+};
+var deleteSubAgentRelation = (db) => async (params) => {
+  const result = await db.delete(subAgentRelations).where(
+    drizzleOrm.and(
+      drizzleOrm.eq(subAgentRelations.tenantId, params.scopes.tenantId),
+      drizzleOrm.eq(subAgentRelations.projectId, params.scopes.projectId),
+      drizzleOrm.eq(subAgentRelations.graphId, params.scopes.graphId),
+      drizzleOrm.eq(subAgentRelations.id, params.relationId)
+    )
+  );
   return (result.rowsAffected || 0) > 0;
 };
 var deleteAgentRelationsByGraph = (db) => async (params) => {
-  const result = await db.delete(agentRelations).where(
+  const result = await db.delete(subAgentRelations).where(
     drizzleOrm.and(
-      drizzleOrm.eq(agentRelations.tenantId, params.scopes.tenantId),
-      drizzleOrm.eq(agentRelations.graphId, params.scopes.graphId)
+      drizzleOrm.eq(subAgentRelations.tenantId, params.scopes.tenantId),
+      drizzleOrm.eq(subAgentRelations.graphId, params.scopes.graphId)
     )
   );
   return (result.rowsAffected || 0) > 0;
 };
 var createAgentToolRelation = (db) => async (params) => {
   const finalRelationId = params.relationId ?? nanoid.nanoid();
-  const relation = await db.insert(agentToolRelations).values({
+  const relation = await db.insert(subAgentToolRelations).values({
     id: finalRelationId,
     tenantId: params.scopes.tenantId,
     projectId: params.scopes.projectId,
     graphId: params.scopes.graphId,
-    agentId: params.data.agentId,
+    subAgentId: params.data.subAgentId,
     toolId: params.data.toolId,
     selectedTools: params.data.selectedTools,
     headers: params.data.headers
@@ -2835,45 +3426,45 @@ var updateAgentToolRelation = (db) => async (params) => {
     ...params.data,
     updatedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
-  const relation = await db.update(agentToolRelations).set(updateData).where(
+  const relation = await db.update(subAgentToolRelations).set(updateData).where(
     drizzleOrm.and(
-      drizzleOrm.eq(agentToolRelations.tenantId, params.scopes.tenantId),
-      drizzleOrm.eq(agentToolRelations.projectId, params.scopes.projectId),
-      drizzleOrm.eq(agentToolRelations.graphId, params.scopes.graphId),
-      drizzleOrm.eq(agentToolRelations.id, params.relationId)
+      drizzleOrm.eq(subAgentToolRelations.tenantId, params.scopes.tenantId),
+      drizzleOrm.eq(subAgentToolRelations.projectId, params.scopes.projectId),
+      drizzleOrm.eq(subAgentToolRelations.graphId, params.scopes.graphId),
+      drizzleOrm.eq(subAgentToolRelations.id, params.relationId)
     )
   ).returning();
   return relation[0];
 };
 var deleteAgentToolRelation = (db) => async (params) => {
-  const result = await db.delete(agentToolRelations).where(
+  const result = await db.delete(subAgentToolRelations).where(
     drizzleOrm.and(
-      drizzleOrm.eq(agentToolRelations.tenantId, params.scopes.tenantId),
-      drizzleOrm.eq(agentToolRelations.projectId, params.scopes.projectId),
-      drizzleOrm.eq(agentToolRelations.graphId, params.scopes.graphId),
-      drizzleOrm.eq(agentToolRelations.id, params.relationId)
+      drizzleOrm.eq(subAgentToolRelations.tenantId, params.scopes.tenantId),
+      drizzleOrm.eq(subAgentToolRelations.projectId, params.scopes.projectId),
+      drizzleOrm.eq(subAgentToolRelations.graphId, params.scopes.graphId),
+      drizzleOrm.eq(subAgentToolRelations.id, params.relationId)
     )
   );
   return (result.rowsAffected || 0) > 0;
 };
 var deleteAgentToolRelationByAgent = (db) => async (params) => {
-  const result = await db.delete(agentToolRelations).where(
+  const result = await db.delete(subAgentToolRelations).where(
     drizzleOrm.and(
-      drizzleOrm.eq(agentToolRelations.tenantId, params.scopes.tenantId),
-      drizzleOrm.eq(agentToolRelations.projectId, params.scopes.projectId),
-      drizzleOrm.eq(agentToolRelations.graphId, params.scopes.graphId),
-      drizzleOrm.eq(agentToolRelations.agentId, params.scopes.agentId)
+      drizzleOrm.eq(subAgentToolRelations.tenantId, params.scopes.tenantId),
+      drizzleOrm.eq(subAgentToolRelations.projectId, params.scopes.projectId),
+      drizzleOrm.eq(subAgentToolRelations.graphId, params.scopes.graphId),
+      drizzleOrm.eq(subAgentToolRelations.subAgentId, params.scopes.subAgentId)
     )
   );
   return (result.rowsAffected || 0) > 0;
 };
 var getAgentToolRelationById = (db) => async (params) => {
-  return await db.query.agentToolRelations.findFirst({
+  return await db.query.subAgentToolRelations.findFirst({
     where: drizzleOrm.and(
-      drizzleOrm.eq(agentToolRelations.tenantId, params.scopes.tenantId),
-      drizzleOrm.eq(agentToolRelations.projectId, params.scopes.projectId),
-      drizzleOrm.eq(agentToolRelations.graphId, params.scopes.graphId),
-      drizzleOrm.eq(agentToolRelations.id, params.relationId)
+      drizzleOrm.eq(subAgentToolRelations.tenantId, params.scopes.tenantId),
+      drizzleOrm.eq(subAgentToolRelations.projectId, params.scopes.projectId),
+      drizzleOrm.eq(subAgentToolRelations.graphId, params.scopes.graphId),
+      drizzleOrm.eq(subAgentToolRelations.id, params.relationId)
     )
   });
 };
@@ -2882,18 +3473,18 @@ var getAgentToolRelationByAgent = (db) => async (params) => {
   const limit = Math.min(params.pagination?.limit || 10, 100);
   const offset = (page - 1) * limit;
   const [data, totalResult] = await Promise.all([
-    db.select().from(agentToolRelations).where(
+    db.select().from(subAgentToolRelations).where(
       drizzleOrm.and(
-        drizzleOrm.eq(agentToolRelations.tenantId, params.scopes.tenantId),
-        drizzleOrm.eq(agentToolRelations.projectId, params.scopes.projectId),
-        drizzleOrm.eq(agentToolRelations.agentId, params.scopes.agentId)
+        drizzleOrm.eq(subAgentToolRelations.tenantId, params.scopes.tenantId),
+        drizzleOrm.eq(subAgentToolRelations.projectId, params.scopes.projectId),
+        drizzleOrm.eq(subAgentToolRelations.subAgentId, params.scopes.subAgentId)
       )
-    ).limit(limit).offset(offset).orderBy(drizzleOrm.desc(agentToolRelations.createdAt)),
-    db.select({ count: drizzleOrm.count() }).from(agentToolRelations).where(
+    ).limit(limit).offset(offset).orderBy(drizzleOrm.desc(subAgentToolRelations.createdAt)),
+    db.select({ count: drizzleOrm.count() }).from(subAgentToolRelations).where(
       drizzleOrm.and(
-        drizzleOrm.eq(agentToolRelations.tenantId, params.scopes.tenantId),
-        drizzleOrm.eq(agentToolRelations.projectId, params.scopes.projectId),
-        drizzleOrm.eq(agentToolRelations.agentId, params.scopes.agentId)
+        drizzleOrm.eq(subAgentToolRelations.tenantId, params.scopes.tenantId),
+        drizzleOrm.eq(subAgentToolRelations.projectId, params.scopes.projectId),
+        drizzleOrm.eq(subAgentToolRelations.subAgentId, params.scopes.subAgentId)
       )
     )
   ]);
@@ -2909,20 +3500,20 @@ var getAgentToolRelationByTool = (db) => async (params) => {
   const limit = Math.min(params.pagination?.limit || 10, 100);
   const offset = (page - 1) * limit;
   const [data, totalResult] = await Promise.all([
-    db.select().from(agentToolRelations).where(
+    db.select().from(subAgentToolRelations).where(
       drizzleOrm.and(
-        drizzleOrm.eq(agentToolRelations.tenantId, params.scopes.tenantId),
-        drizzleOrm.eq(agentToolRelations.projectId, params.scopes.projectId),
-        drizzleOrm.eq(agentToolRelations.graphId, params.scopes.graphId),
-        drizzleOrm.eq(agentToolRelations.toolId, params.toolId)
+        drizzleOrm.eq(subAgentToolRelations.tenantId, params.scopes.tenantId),
+        drizzleOrm.eq(subAgentToolRelations.projectId, params.scopes.projectId),
+        drizzleOrm.eq(subAgentToolRelations.graphId, params.scopes.graphId),
+        drizzleOrm.eq(subAgentToolRelations.toolId, params.toolId)
       )
-    ).limit(limit).offset(offset).orderBy(drizzleOrm.desc(agentToolRelations.createdAt)),
-    db.select({ count: drizzleOrm.count() }).from(agentToolRelations).where(
+    ).limit(limit).offset(offset).orderBy(drizzleOrm.desc(subAgentToolRelations.createdAt)),
+    db.select({ count: drizzleOrm.count() }).from(subAgentToolRelations).where(
       drizzleOrm.and(
-        drizzleOrm.eq(agentToolRelations.tenantId, params.scopes.tenantId),
-        drizzleOrm.eq(agentToolRelations.projectId, params.scopes.projectId),
-        drizzleOrm.eq(agentToolRelations.graphId, params.scopes.graphId),
-        drizzleOrm.eq(agentToolRelations.toolId, params.toolId)
+        drizzleOrm.eq(subAgentToolRelations.tenantId, params.scopes.tenantId),
+        drizzleOrm.eq(subAgentToolRelations.projectId, params.scopes.projectId),
+        drizzleOrm.eq(subAgentToolRelations.graphId, params.scopes.graphId),
+        drizzleOrm.eq(subAgentToolRelations.toolId, params.toolId)
       )
     )
   ]);
@@ -2938,18 +3529,18 @@ var listAgentToolRelations = (db) => async (params) => {
   const limit = Math.min(params.pagination?.limit || 10, 100);
   const offset = (page - 1) * limit;
   const [data, totalResult] = await Promise.all([
-    db.select().from(agentToolRelations).where(
+    db.select().from(subAgentToolRelations).where(
       drizzleOrm.and(
-        drizzleOrm.eq(agentToolRelations.tenantId, params.scopes.tenantId),
-        drizzleOrm.eq(agentToolRelations.projectId, params.scopes.projectId),
-        drizzleOrm.eq(agentToolRelations.graphId, params.scopes.graphId)
+        drizzleOrm.eq(subAgentToolRelations.tenantId, params.scopes.tenantId),
+        drizzleOrm.eq(subAgentToolRelations.projectId, params.scopes.projectId),
+        drizzleOrm.eq(subAgentToolRelations.graphId, params.scopes.graphId)
       )
-    ).limit(limit).offset(offset).orderBy(drizzleOrm.desc(agentToolRelations.createdAt)),
-    db.select({ count: drizzleOrm.count() }).from(agentToolRelations).where(
+    ).limit(limit).offset(offset).orderBy(drizzleOrm.desc(subAgentToolRelations.createdAt)),
+    db.select({ count: drizzleOrm.count() }).from(subAgentToolRelations).where(
       drizzleOrm.and(
-        drizzleOrm.eq(agentToolRelations.tenantId, params.scopes.tenantId),
-        drizzleOrm.eq(agentToolRelations.projectId, params.scopes.projectId),
-        drizzleOrm.eq(agentToolRelations.graphId, params.scopes.graphId)
+        drizzleOrm.eq(subAgentToolRelations.tenantId, params.scopes.tenantId),
+        drizzleOrm.eq(subAgentToolRelations.projectId, params.scopes.projectId),
+        drizzleOrm.eq(subAgentToolRelations.graphId, params.scopes.graphId)
       )
     )
   ]);
@@ -2966,14 +3557,14 @@ var getToolsForAgent = (db) => async (params) => {
   const offset = (page - 1) * limit;
   const [data, totalResult] = await Promise.all([
     db.select({
-      id: agentToolRelations.id,
-      tenantId: agentToolRelations.tenantId,
-      agentId: agentToolRelations.agentId,
-      toolId: agentToolRelations.toolId,
-      selectedTools: agentToolRelations.selectedTools,
-      headers: agentToolRelations.headers,
-      createdAt: agentToolRelations.createdAt,
-      updatedAt: agentToolRelations.updatedAt,
+      id: subAgentToolRelations.id,
+      tenantId: subAgentToolRelations.tenantId,
+      subAgentId: subAgentToolRelations.subAgentId,
+      toolId: subAgentToolRelations.toolId,
+      selectedTools: subAgentToolRelations.selectedTools,
+      headers: subAgentToolRelations.headers,
+      createdAt: subAgentToolRelations.createdAt,
+      updatedAt: subAgentToolRelations.updatedAt,
       tool: {
         id: tools.id,
         name: tools.name,
@@ -2990,27 +3581,27 @@ var getToolsForAgent = (db) => async (params) => {
         headers: tools.headers,
         imageUrl: tools.imageUrl
       }
-    }).from(agentToolRelations).innerJoin(
+    }).from(subAgentToolRelations).innerJoin(
       tools,
       drizzleOrm.and(
-        drizzleOrm.eq(agentToolRelations.tenantId, tools.tenantId),
-        drizzleOrm.eq(agentToolRelations.projectId, tools.projectId),
-        drizzleOrm.eq(agentToolRelations.toolId, tools.id)
+        drizzleOrm.eq(subAgentToolRelations.tenantId, tools.tenantId),
+        drizzleOrm.eq(subAgentToolRelations.projectId, tools.projectId),
+        drizzleOrm.eq(subAgentToolRelations.toolId, tools.id)
       )
     ).where(
       drizzleOrm.and(
-        drizzleOrm.eq(agentToolRelations.tenantId, params.scopes.tenantId),
-        drizzleOrm.eq(agentToolRelations.projectId, params.scopes.projectId),
-        drizzleOrm.eq(agentToolRelations.graphId, params.scopes.graphId),
-        drizzleOrm.eq(agentToolRelations.agentId, params.scopes.agentId)
+        drizzleOrm.eq(subAgentToolRelations.tenantId, params.scopes.tenantId),
+        drizzleOrm.eq(subAgentToolRelations.projectId, params.scopes.projectId),
+        drizzleOrm.eq(subAgentToolRelations.graphId, params.scopes.graphId),
+        drizzleOrm.eq(subAgentToolRelations.subAgentId, params.scopes.subAgentId)
       )
-    ).limit(limit).offset(offset).orderBy(drizzleOrm.desc(agentToolRelations.createdAt)),
-    db.select({ count: drizzleOrm.count() }).from(agentToolRelations).where(
+    ).limit(limit).offset(offset).orderBy(drizzleOrm.desc(subAgentToolRelations.createdAt)),
+    db.select({ count: drizzleOrm.count() }).from(subAgentToolRelations).where(
       drizzleOrm.and(
-        drizzleOrm.eq(agentToolRelations.tenantId, params.scopes.tenantId),
-        drizzleOrm.eq(agentToolRelations.projectId, params.scopes.projectId),
-        drizzleOrm.eq(agentToolRelations.graphId, params.scopes.graphId),
-        drizzleOrm.eq(agentToolRelations.agentId, params.scopes.agentId)
+        drizzleOrm.eq(subAgentToolRelations.tenantId, params.scopes.tenantId),
+        drizzleOrm.eq(subAgentToolRelations.projectId, params.scopes.projectId),
+        drizzleOrm.eq(subAgentToolRelations.graphId, params.scopes.graphId),
+        drizzleOrm.eq(subAgentToolRelations.subAgentId, params.scopes.subAgentId)
       )
     )
   ]);
@@ -3027,560 +3618,200 @@ var getAgentsForTool = (db) => async (params) => {
   const offset = (page - 1) * limit;
   const [data, totalResult] = await Promise.all([
     db.select({
-      id: agentToolRelations.id,
-      tenantId: agentToolRelations.tenantId,
-      agentId: agentToolRelations.agentId,
-      toolId: agentToolRelations.toolId,
-      selectedTools: agentToolRelations.selectedTools,
-      headers: agentToolRelations.headers,
-      createdAt: agentToolRelations.createdAt,
-      updatedAt: agentToolRelations.updatedAt,
-      agent: {
-        id: agents.id,
-        name: agents.name,
-        description: agents.description,
-        prompt: agents.prompt,
-        conversationHistoryConfig: agents.conversationHistoryConfig,
-        models: agents.models,
-        stopWhen: agents.stopWhen,
-        createdAt: agents.createdAt,
-        updatedAt: agents.updatedAt
-      }
-    }).from(agentToolRelations).innerJoin(
-      agents,
+      id: subAgentToolRelations.id,
+      tenantId: subAgentToolRelations.tenantId,
+      subAgentId: subAgentToolRelations.subAgentId,
+      toolId: subAgentToolRelations.toolId,
+      selectedTools: subAgentToolRelations.selectedTools,
+      headers: subAgentToolRelations.headers,
+      createdAt: subAgentToolRelations.createdAt,
+      updatedAt: subAgentToolRelations.updatedAt,
+      subAgent: {
+        id: subAgents.id,
+        name: subAgents.name,
+        description: subAgents.description,
+        prompt: subAgents.prompt,
+        conversationHistoryConfig: subAgents.conversationHistoryConfig,
+        models: subAgents.models,
+        stopWhen: subAgents.stopWhen,
+        createdAt: subAgents.createdAt,
+        updatedAt: subAgents.updatedAt
+      }
+    }).from(subAgentToolRelations).innerJoin(
+      subAgents,
       drizzleOrm.and(
-        drizzleOrm.eq(agentToolRelations.agentId, agents.id),
-        drizzleOrm.eq(agentToolRelations.tenantId, agents.tenantId),
-        drizzleOrm.eq(agentToolRelations.projectId, agents.projectId),
-        drizzleOrm.eq(agentToolRelations.graphId, agents.graphId)
+        drizzleOrm.eq(subAgentToolRelations.subAgentId, subAgents.id),
+        drizzleOrm.eq(subAgentToolRelations.tenantId, subAgents.tenantId),
+        drizzleOrm.eq(subAgentToolRelations.projectId, subAgents.projectId),
+        drizzleOrm.eq(subAgentToolRelations.graphId, subAgents.graphId)
       )
     ).where(
       drizzleOrm.and(
-        drizzleOrm.eq(agentToolRelations.tenantId, params.scopes.tenantId),
-        drizzleOrm.eq(agentToolRelations.projectId, params.scopes.projectId),
-        drizzleOrm.eq(agentToolRelations.graphId, params.scopes.graphId),
-        drizzleOrm.eq(agentToolRelations.toolId, params.toolId)
-      )
-    ).limit(limit).offset(offset).orderBy(drizzleOrm.desc(agentToolRelations.createdAt)),
-    db.select({ count: drizzleOrm.count() }).from(agentToolRelations).where(
-      drizzleOrm.and(
-        drizzleOrm.eq(agentToolRelations.tenantId, params.scopes.tenantId),
-        drizzleOrm.eq(agentToolRelations.projectId, params.scopes.projectId),
-        drizzleOrm.eq(agentToolRelations.graphId, params.scopes.graphId),
-        drizzleOrm.eq(agentToolRelations.toolId, params.toolId)
+        drizzleOrm.eq(subAgentToolRelations.tenantId, params.scopes.tenantId),
+        drizzleOrm.eq(subAgentToolRelations.projectId, params.scopes.projectId),
+        drizzleOrm.eq(subAgentToolRelations.graphId, params.scopes.graphId),
+        drizzleOrm.eq(subAgentToolRelations.toolId, params.toolId)
       )
-    )
-  ]);
-  const total = totalResult[0]?.count || 0;
-  const pages = Math.ceil(total / limit);
-  return {
-    data,
-    pagination: { page, limit, total, pages }
-  };
-};
-var validateInternalAgent = (db) => async (params) => {
-  const result = await db.select({ id: agents.id }).from(agents).where(
-    drizzleOrm.and(
-      drizzleOrm.eq(agents.tenantId, params.scopes.tenantId),
-      drizzleOrm.eq(agents.projectId, params.scopes.projectId),
-      drizzleOrm.eq(agents.graphId, params.scopes.graphId),
-      drizzleOrm.eq(agents.id, params.scopes.agentId)
-    )
-  ).limit(1);
-  return result.length > 0;
-};
-var validateExternalAgent = (db) => async (params) => {
-  const result = await db.select({ id: externalAgents.id }).from(externalAgents).where(
-    drizzleOrm.and(
-      drizzleOrm.eq(externalAgents.tenantId, params.scopes.tenantId),
-      drizzleOrm.eq(externalAgents.projectId, params.scopes.projectId),
-      drizzleOrm.eq(externalAgents.graphId, params.scopes.graphId),
-      drizzleOrm.eq(externalAgents.id, params.scopes.agentId)
-    )
-  ).limit(1);
-  return result.length > 0;
-};
-var getAgentById = (db) => async (params) => {
-  const result = await db.query.agents.findFirst({
-    where: drizzleOrm.and(
-      drizzleOrm.eq(agents.tenantId, params.scopes.tenantId),
-      drizzleOrm.eq(agents.projectId, params.scopes.projectId),
-      drizzleOrm.eq(agents.graphId, params.scopes.graphId),
-      drizzleOrm.eq(agents.id, params.agentId)
-    )
-  });
-  return result;
-};
-var listAgents = (db) => async (params) => {
-  return await db.query.agents.findMany({
-    where: drizzleOrm.and(
-      drizzleOrm.eq(agents.tenantId, params.scopes.tenantId),
-      drizzleOrm.eq(agents.projectId, params.scopes.projectId),
-      drizzleOrm.eq(agents.graphId, params.scopes.graphId)
-    )
-  });
-};
-var listAgentsPaginated = (db) => async (params) => {
-  const page = params.pagination?.page || 1;
-  const limit = Math.min(params.pagination?.limit || 10, 100);
-  const offset = (page - 1) * limit;
-  const whereClause = drizzleOrm.and(
-    drizzleOrm.eq(agents.tenantId, params.scopes.tenantId),
-    drizzleOrm.eq(agents.projectId, params.scopes.projectId),
-    drizzleOrm.eq(agents.graphId, params.scopes.graphId)
-  );
-  const [data, totalResult] = await Promise.all([
-    db.select().from(agents).where(whereClause).limit(limit).offset(offset).orderBy(drizzleOrm.desc(agents.createdAt)),
-    db.select({ count: drizzleOrm.count() }).from(agents).where(whereClause)
-  ]);
-  const total = totalResult[0]?.count || 0;
-  const pages = Math.ceil(total / limit);
-  return {
-    data,
-    pagination: { page, limit, total, pages }
-  };
-};
-var createAgent = (db) => async (params) => {
-  const agent = await db.insert(agents).values(params).returning();
-  return agent[0];
-};
-var updateAgent = (db) => async (params) => {
-  const data = params.data;
-  if (data.models !== void 0) {
-    if (!data.models || !data.models.base?.model && !data.models.structuredOutput?.model && !data.models.summarizer?.model && !data.models.base?.providerOptions && !data.models.structuredOutput?.providerOptions && !data.models.summarizer?.providerOptions) {
-      data.models = null;
-    }
-  }
-  const updateData = {
-    ...data,
-    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-  };
-  const agent = await db.update(agents).set(updateData).where(
-    drizzleOrm.and(
-      drizzleOrm.eq(agents.tenantId, params.scopes.tenantId),
-      drizzleOrm.eq(agents.projectId, params.scopes.projectId),
-      drizzleOrm.eq(agents.graphId, params.scopes.graphId),
-      drizzleOrm.eq(agents.id, params.agentId)
-    )
-  ).returning();
-  return agent[0] ?? null;
-};
-var upsertAgent = (db) => async (params) => {
-  const scopes = {
-    tenantId: params.data.tenantId,
-    projectId: params.data.projectId,
-    graphId: params.data.graphId
-  };
-  const existing = await getAgentById(db)({
-    scopes,
-    agentId: params.data.id
-  });
-  if (existing) {
-    const updated = await updateAgent(db)({
-      scopes,
-      agentId: params.data.id,
-      data: {
-        name: params.data.name,
-        description: params.data.description,
-        prompt: params.data.prompt,
-        conversationHistoryConfig: params.data.conversationHistoryConfig,
-        models: params.data.models,
-        stopWhen: params.data.stopWhen
-      }
-    });
-    if (!updated) {
-      throw new Error("Failed to update agent - no rows affected");
-    }
-    return updated;
-  } else {
-    return await createAgent(db)(params.data);
-  }
-};
-var deleteAgent = (db) => async (params) => {
-  await db.delete(agents).where(
-    drizzleOrm.and(
-      drizzleOrm.eq(agents.tenantId, params.scopes.tenantId),
-      drizzleOrm.eq(agents.projectId, params.scopes.projectId),
-      drizzleOrm.eq(agents.graphId, params.scopes.graphId),
-      drizzleOrm.eq(agents.id, params.agentId)
-    )
-  );
-  const deletedAgent = await getAgentById(db)({
-    scopes: params.scopes,
-    agentId: params.agentId
-  });
-  return deletedAgent === void 0;
-};
-var getAgentsByIds = (db) => async (params) => {
-  if (params.agentIds.length === 0) {
-    return [];
-  }
-  return await db.select().from(agents).where(
-    drizzleOrm.and(
-      drizzleOrm.eq(agents.tenantId, params.scopes.tenantId),
-      drizzleOrm.eq(agents.projectId, params.scopes.projectId),
-      drizzleOrm.eq(agents.graphId, params.scopes.graphId),
-      drizzleOrm.inArray(agents.id, params.agentIds)
-    )
-  );
-};
-var getContextConfigById = (db) => async (params) => {
-  return await db.query.contextConfigs.findFirst({
-    where: drizzleOrm.and(
-      drizzleOrm.eq(contextConfigs.tenantId, params.scopes.tenantId),
-      drizzleOrm.eq(contextConfigs.projectId, params.scopes.projectId),
-      drizzleOrm.eq(contextConfigs.graphId, params.scopes.graphId),
-      drizzleOrm.eq(contextConfigs.id, params.id)
-    )
-  });
-};
-var listContextConfigs = (db) => async (params) => {
-  return await db.query.contextConfigs.findMany({
-    where: drizzleOrm.and(
-      drizzleOrm.eq(contextConfigs.tenantId, params.scopes.tenantId),
-      drizzleOrm.eq(contextConfigs.projectId, params.scopes.projectId),
-      drizzleOrm.eq(contextConfigs.graphId, params.scopes.graphId)
-    ),
-    orderBy: [drizzleOrm.desc(contextConfigs.createdAt)]
-  });
-};
-var listContextConfigsPaginated = (db) => async (params) => {
-  const page = params.pagination?.page || 1;
-  const limit = Math.min(params.pagination?.limit || 10, 100);
-  const offset = (page - 1) * limit;
-  const whereClause = drizzleOrm.and(
-    drizzleOrm.eq(contextConfigs.tenantId, params.scopes.tenantId),
-    drizzleOrm.eq(contextConfigs.projectId, params.scopes.projectId),
-    drizzleOrm.eq(contextConfigs.graphId, params.scopes.graphId)
-  );
-  const [contextConfigList, totalResult] = await Promise.all([
-    db.select().from(contextConfigs).where(whereClause).limit(limit).offset(offset).orderBy(drizzleOrm.desc(contextConfigs.createdAt)),
-    db.select({ count: drizzleOrm.sql`COUNT(*)` }).from(contextConfigs).where(whereClause)
-  ]);
-  const total = Number(totalResult[0]?.count || 0);
-  const pages = Math.ceil(total / limit);
-  return {
-    data: contextConfigList,
-    pagination: {
-      page,
-      limit,
-      total,
-      pages
-    }
-  };
-};
-var createContextConfig = (db) => async (params) => {
-  const id = params.id || nanoid.nanoid();
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  let contextVariables = params.contextVariables;
-  if (contextVariables !== void 0 && contextVariables !== null && typeof contextVariables === "object" && Object.keys(contextVariables).length === 0) {
-    contextVariables = null;
-  }
-  const contextConfig2 = await db.insert(contextConfigs).values({
-    id,
-    tenantId: params.tenantId,
-    projectId: params.projectId,
-    graphId: params.graphId,
-    headersSchema: params.headersSchema ?? null,
-    contextVariables: contextVariables ?? null,
-    createdAt: now,
-    updatedAt: now
-  }).returning();
-  return contextConfig2[0];
-};
-var updateContextConfig = (db) => async (params) => {
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  const processedData = { ...params.data };
-  if ("contextVariables" in params.data) {
-    if (params.data.contextVariables === null || typeof params.data.contextVariables === "object" && params.data.contextVariables !== null && Object.keys(params.data.contextVariables).length === 0) {
-      processedData.contextVariables = null;
-    }
-  }
-  if ("headersSchema" in params.data && params.data.headersSchema === null) {
-    processedData.headersSchema = null;
-  }
-  const updated = await db.update(contextConfigs).set({
-    ...processedData,
-    updatedAt: now
-  }).where(
-    drizzleOrm.and(
-      drizzleOrm.eq(contextConfigs.tenantId, params.scopes.tenantId),
-      drizzleOrm.eq(contextConfigs.projectId, params.scopes.projectId),
-      drizzleOrm.eq(contextConfigs.graphId, params.scopes.graphId),
-      drizzleOrm.eq(contextConfigs.id, params.id)
-    )
-  ).returning();
-  return updated[0];
-};
-var deleteContextConfig = (db) => async (params) => {
-  try {
-    const result = await db.delete(contextConfigs).where(
-      drizzleOrm.and(
-        drizzleOrm.eq(contextConfigs.tenantId, params.scopes.tenantId),
-        drizzleOrm.eq(contextConfigs.projectId, params.scopes.projectId),
-        drizzleOrm.eq(contextConfigs.graphId, params.scopes.graphId),
-        drizzleOrm.eq(contextConfigs.id, params.id)
+    ).limit(limit).offset(offset).orderBy(drizzleOrm.desc(subAgentToolRelations.createdAt)),
+    db.select({ count: drizzleOrm.count() }).from(subAgentToolRelations).where(
+      drizzleOrm.and(
+        drizzleOrm.eq(subAgentToolRelations.tenantId, params.scopes.tenantId),
+        drizzleOrm.eq(subAgentToolRelations.projectId, params.scopes.projectId),
+        drizzleOrm.eq(subAgentToolRelations.graphId, params.scopes.graphId),
+        drizzleOrm.eq(subAgentToolRelations.toolId, params.toolId)
       )
-    ).returning();
-    return result.length > 0;
-  } catch (error) {
-    console.error("Error deleting context config:", error);
-    return false;
-  }
-};
-var hasContextConfig = (db) => async (params) => {
-  const contextConfig2 = await getContextConfigById(db)(params);
-  return contextConfig2 !== null;
-};
-var countContextConfigs = (db) => async (params) => {
-  const result = await db.select({ count: drizzleOrm.count() }).from(contextConfigs).where(
-    drizzleOrm.and(
-      drizzleOrm.eq(contextConfigs.tenantId, params.scopes.tenantId),
-      drizzleOrm.eq(contextConfigs.projectId, params.scopes.projectId),
-      drizzleOrm.eq(contextConfigs.graphId, params.scopes.graphId)
     )
-  );
-  const total = result[0]?.count || 0;
-  return typeof total === "string" ? Number.parseInt(total, 10) : total;
-};
-var upsertContextConfig = (db) => async (params) => {
-  const scopes = {
-    tenantId: params.data.tenantId,
-    projectId: params.data.projectId,
-    graphId: params.data.graphId
+  ]);
+  const total = totalResult[0]?.count || 0;
+  const pages = Math.ceil(total / limit);
+  return {
+    data,
+    pagination: { page, limit, total, pages }
   };
-  if (params.data.id) {
-    const existing = await getContextConfigById(db)({
-      scopes,
-      id: params.data.id
-    });
-    if (existing) {
-      return await updateContextConfig(db)({
-        scopes,
-        id: params.data.id,
-        data: {
-          headersSchema: params.data.headersSchema,
-          contextVariables: params.data.contextVariables
-        }
-      });
-    }
-  }
-  return await createContextConfig(db)(params.data);
 };
-var createExternalAgent = (db) => async (params) => {
-  const agent = await db.insert(externalAgents).values(params).returning();
-  return agent[0];
+var validateInternalSubAgent = (db) => async (params) => {
+  const result = await db.select({ id: subAgents.id }).from(subAgents).where(
+    drizzleOrm.and(
+      drizzleOrm.eq(subAgents.tenantId, params.scopes.tenantId),
+      drizzleOrm.eq(subAgents.projectId, params.scopes.projectId),
+      drizzleOrm.eq(subAgents.graphId, params.scopes.graphId),
+      drizzleOrm.eq(subAgents.id, params.scopes.subAgentId)
+    )
+  ).limit(1);
+  return result.length > 0;
 };
-var getExternalAgent = (db) => async (params) => {
-  const result = await db.query.externalAgents.findFirst({
-    where: drizzleOrm.and(
+var validateExternalAgent = (db) => async (params) => {
+  const result = await db.select({ id: externalAgents.id }).from(externalAgents).where(
+    drizzleOrm.and(
       drizzleOrm.eq(externalAgents.tenantId, params.scopes.tenantId),
       drizzleOrm.eq(externalAgents.projectId, params.scopes.projectId),
       drizzleOrm.eq(externalAgents.graphId, params.scopes.graphId),
-      drizzleOrm.eq(externalAgents.id, params.agentId)
+      drizzleOrm.eq(externalAgents.id, params.scopes.subAgentId)
     )
-  });
-  return result || null;
+  ).limit(1);
+  return result.length > 0;
 };
-var getExternalAgentByUrl = (db) => async (params) => {
-  const result = await db.query.externalAgents.findFirst({
+var getSubAgentById = (db) => async (params) => {
+  const result = await db.query.subAgents.findFirst({
     where: drizzleOrm.and(
-      drizzleOrm.eq(externalAgents.tenantId, params.scopes.tenantId),
-      drizzleOrm.eq(externalAgents.projectId, params.scopes.projectId),
-      drizzleOrm.eq(externalAgents.graphId, params.scopes.graphId),
-      drizzleOrm.eq(externalAgents.baseUrl, params.baseUrl)
+      drizzleOrm.eq(subAgents.tenantId, params.scopes.tenantId),
+      drizzleOrm.eq(subAgents.projectId, params.scopes.projectId),
+      drizzleOrm.eq(subAgents.graphId, params.scopes.graphId),
+      drizzleOrm.eq(subAgents.id, params.subAgentId)
     )
   });
-  return result || null;
+  return result;
 };
-var listExternalAgents = (db) => async (params) => {
-  return await db.query.externalAgents.findMany({
+var listSubAgents = (db) => async (params) => {
+  return await db.query.subAgents.findMany({
     where: drizzleOrm.and(
-      drizzleOrm.eq(externalAgents.tenantId, params.scopes.tenantId),
-      drizzleOrm.eq(externalAgents.projectId, params.scopes.projectId),
-      drizzleOrm.eq(externalAgents.graphId, params.scopes.graphId)
-    ),
-    orderBy: [drizzleOrm.asc(externalAgents.name)]
+      drizzleOrm.eq(subAgents.tenantId, params.scopes.tenantId),
+      drizzleOrm.eq(subAgents.projectId, params.scopes.projectId),
+      drizzleOrm.eq(subAgents.graphId, params.scopes.graphId)
+    )
   });
 };
-var listExternalAgentsPaginated = (db) => async (params) => {
+var listSubAgentsPaginated = (db) => async (params) => {
   const page = params.pagination?.page || 1;
   const limit = Math.min(params.pagination?.limit || 10, 100);
   const offset = (page - 1) * limit;
+  const whereClause = drizzleOrm.and(
+    drizzleOrm.eq(subAgents.tenantId, params.scopes.tenantId),
+    drizzleOrm.eq(subAgents.projectId, params.scopes.projectId),
+    drizzleOrm.eq(subAgents.graphId, params.scopes.graphId)
+  );
   const [data, totalResult] = await Promise.all([
-    db.select().from(externalAgents).where(
-      drizzleOrm.and(
-        drizzleOrm.eq(externalAgents.tenantId, params.scopes.tenantId),
-        drizzleOrm.eq(externalAgents.projectId, params.scopes.projectId),
-        drizzleOrm.eq(externalAgents.graphId, params.scopes.graphId)
-      )
-    ).limit(limit).offset(offset).orderBy(drizzleOrm.desc(externalAgents.createdAt)),
-    db.select({ count: drizzleOrm.count() }).from(externalAgents).where(
-      drizzleOrm.and(
-        drizzleOrm.eq(externalAgents.tenantId, params.scopes.tenantId),
-        drizzleOrm.eq(externalAgents.projectId, params.scopes.projectId),
-        drizzleOrm.eq(externalAgents.graphId, params.scopes.graphId)
-      )
-    )
+    db.select().from(subAgents).where(whereClause).limit(limit).offset(offset).orderBy(drizzleOrm.desc(subAgents.createdAt)),
+    db.select({ count: drizzleOrm.count() }).from(subAgents).where(whereClause)
   ]);
-  const total = typeof totalResult[0]?.count === "string" ? parseInt(totalResult[0].count, 10) : totalResult[0]?.count || 0;
+  const total = totalResult[0]?.count || 0;
   const pages = Math.ceil(total / limit);
   return {
     data,
     pagination: { page, limit, total, pages }
   };
 };
-var updateExternalAgent = (db) => async (params) => {
+var createSubAgent = (db) => async (params) => {
+  const agent = await db.insert(subAgents).values(params).returning();
+  return agent[0];
+};
+var updateSubAgent = (db) => async (params) => {
+  const data = params.data;
+  if (data.models !== void 0) {
+    if (!data.models || !data.models.base?.model && !data.models.structuredOutput?.model && !data.models.summarizer?.model && !data.models.base?.providerOptions && !data.models.structuredOutput?.providerOptions && !data.models.summarizer?.providerOptions) {
+      data.models = null;
+    }
+  }
   const updateData = {
-    ...params.data,
+    ...data,
     updatedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
-  if (Object.keys(updateData).length === 1) {
-    throw new Error("No fields to update");
-  }
-  if (updateData.headers !== void 0 && (updateData.headers === null || Object.keys(updateData.headers || {}).length === 0)) {
-    updateData.headers = null;
-  }
-  if (updateData.credentialReferenceId === void 0) {
-    updateData.credentialReferenceId = null;
-  }
-  const result = await db.update(externalAgents).set(updateData).where(
+  const agent = await db.update(subAgents).set(updateData).where(
     drizzleOrm.and(
-      drizzleOrm.eq(externalAgents.tenantId, params.scopes.tenantId),
-      drizzleOrm.eq(externalAgents.projectId, params.scopes.projectId),
-      drizzleOrm.eq(externalAgents.graphId, params.scopes.graphId),
-      drizzleOrm.eq(externalAgents.id, params.agentId)
+      drizzleOrm.eq(subAgents.tenantId, params.scopes.tenantId),
+      drizzleOrm.eq(subAgents.projectId, params.scopes.projectId),
+      drizzleOrm.eq(subAgents.graphId, params.scopes.graphId),
+      drizzleOrm.eq(subAgents.id, params.subAgentId)
     )
   ).returning();
-  return result[0] || null;
+  return agent[0] ?? null;
 };
-var upsertExternalAgent = (db) => async (params) => {
+var upsertSubAgent = (db) => async (params) => {
   const scopes = {
     tenantId: params.data.tenantId,
     projectId: params.data.projectId,
     graphId: params.data.graphId
   };
-  const existing = await getExternalAgent(db)({
+  const existing = await getSubAgentById(db)({
     scopes,
-    agentId: params.data.id
+    subAgentId: params.data.id
   });
   if (existing) {
-    const updated = await updateExternalAgent(db)({
+    const updated = await updateSubAgent(db)({
       scopes,
-      agentId: params.data.id,
+      subAgentId: params.data.id,
       data: {
         name: params.data.name,
         description: params.data.description,
-        baseUrl: params.data.baseUrl,
-        credentialReferenceId: params.data.credentialReferenceId,
-        headers: params.data.headers
+        prompt: params.data.prompt,
+        conversationHistoryConfig: params.data.conversationHistoryConfig,
+        models: params.data.models,
+        stopWhen: params.data.stopWhen
       }
     });
     if (!updated) {
-      throw new Error("Failed to update external agent - no rows affected");
+      throw new Error("Failed to update agent - no rows affected");
     }
     return updated;
   } else {
-    return await createExternalAgent(db)(params.data);
-  }
-};
-var deleteExternalAgent = (db) => async (params) => {
-  try {
-    const result = await db.delete(externalAgents).where(
-      drizzleOrm.and(
-        drizzleOrm.eq(externalAgents.tenantId, params.scopes.tenantId),
-        drizzleOrm.eq(externalAgents.projectId, params.scopes.projectId),
-        drizzleOrm.eq(externalAgents.graphId, params.scopes.graphId),
-        drizzleOrm.eq(externalAgents.id, params.agentId)
-      )
-    ).returning();
-    return result.length > 0;
-  } catch (error) {
-    console.error("Error deleting external agent:", error);
-    return false;
+    return await createSubAgent(db)(params.data);
   }
 };
-var externalAgentExists = (db) => async (params) => {
-  const agent = await getExternalAgent(db)(params);
-  return agent !== null;
-};
-var externalAgentUrlExists = (db) => async (params) => {
-  const agent = await getExternalAgentByUrl(db)(params);
-  return agent !== null;
-};
-var countExternalAgents = (db) => async (params) => {
-  const result = await db.select({ count: drizzleOrm.count() }).from(externalAgents).where(
+var deleteSubAgent = (db) => async (params) => {
+  await db.delete(subAgents).where(
     drizzleOrm.and(
-      drizzleOrm.eq(externalAgents.tenantId, params.scopes.tenantId),
-      drizzleOrm.eq(externalAgents.projectId, params.scopes.projectId),
-      drizzleOrm.eq(externalAgents.graphId, params.scopes.graphId)
+      drizzleOrm.eq(subAgents.tenantId, params.scopes.tenantId),
+      drizzleOrm.eq(subAgents.projectId, params.scopes.projectId),
+      drizzleOrm.eq(subAgents.graphId, params.scopes.graphId),
+      drizzleOrm.eq(subAgents.id, params.subAgentId)
     )
   );
-  const countValue = result[0]?.count;
-  return typeof countValue === "string" ? parseInt(countValue, 10) : countValue || 0;
+  const deletedSubAgent = await getSubAgentById(db)({
+    scopes: params.scopes,
+    subAgentId: params.subAgentId
+  });
+  return deletedSubAgent === void 0;
 };
-var upsertFunction = (db) => async (params) => {
-  const { data, scopes } = params;
-  const { tenantId, projectId } = scopes;
-  const existingFunction = await db.select().from(functions).where(
-    drizzleOrm.and(
-      drizzleOrm.eq(functions.tenantId, tenantId),
-      drizzleOrm.eq(functions.projectId, projectId),
-      drizzleOrm.eq(functions.id, data.id)
-    )
-  ).limit(1);
-  if (existingFunction.length > 0) {
-    await db.update(functions).set({
-      inputSchema: data.inputSchema,
-      executeCode: data.executeCode,
-      dependencies: data.dependencies,
-      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-    }).where(
-      drizzleOrm.and(
-        drizzleOrm.eq(functions.tenantId, tenantId),
-        drizzleOrm.eq(functions.projectId, projectId),
-        drizzleOrm.eq(functions.id, data.id)
-      )
-    );
-  } else {
-    await db.insert(functions).values({
-      tenantId,
-      projectId,
-      id: data.id,
-      inputSchema: data.inputSchema,
-      executeCode: data.executeCode,
-      dependencies: data.dependencies,
-      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
-      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-    });
+var getSubAgentsByIds = (db) => async (params) => {
+  if (params.subAgentIds.length === 0) {
+    return [];
   }
-};
-var getFunction = (db) => async (params) => {
-  const { functionId, scopes } = params;
-  const { tenantId, projectId } = scopes;
-  const result = await db.select().from(functions).where(
-    drizzleOrm.and(
-      drizzleOrm.eq(functions.tenantId, tenantId),
-      drizzleOrm.eq(functions.projectId, projectId),
-      drizzleOrm.eq(functions.id, functionId)
-    )
-  ).limit(1);
-  return result[0] || null;
-};
-var listFunctions = (db) => async (params) => {
-  const { scopes } = params;
-  const { tenantId, projectId } = scopes;
-  const result = await db.select().from(functions).where(drizzleOrm.and(drizzleOrm.eq(functions.tenantId, tenantId), drizzleOrm.eq(functions.projectId, projectId)));
-  return result;
-};
-var deleteFunction = (db) => async (params) => {
-  const { functionId, scopes } = params;
-  const { tenantId, projectId } = scopes;
-  await db.delete(functions).where(
+  return await db.select().from(subAgents).where(
     drizzleOrm.and(
-      drizzleOrm.eq(functions.tenantId, tenantId),
-      drizzleOrm.eq(functions.projectId, projectId),
-      drizzleOrm.eq(functions.id, functionId)
+      drizzleOrm.eq(subAgents.tenantId, params.scopes.tenantId),
+      drizzleOrm.eq(subAgents.projectId, params.scopes.projectId),
+      drizzleOrm.eq(subAgents.graphId, params.scopes.graphId),
+      drizzleOrm.inArray(subAgents.id, params.subAgentIds)
     )
   );
 };
@@ -4661,12 +4892,12 @@ var deleteTool = (db) => async (params) => {
 var addToolToAgent = (db) => async (params) => {
   const id = nanoid.nanoid();
   const now = (/* @__PURE__ */ new Date()).toISOString();
-  const [created] = await db.insert(agentToolRelations).values({
+  const [created] = await db.insert(subAgentToolRelations).values({
     id,
     tenantId: params.scopes.tenantId,
     projectId: params.scopes.projectId,
     graphId: params.scopes.graphId,
-    agentId: params.agentId,
+    subAgentId: params.subAgentId,
     toolId: params.toolId,
     selectedTools: params.selectedTools,
     headers: params.headers,
@@ -4676,13 +4907,13 @@ var addToolToAgent = (db) => async (params) => {
   return created;
 };
 var removeToolFromAgent = (db) => async (params) => {
-  const [deleted] = await db.delete(agentToolRelations).where(
+  const [deleted] = await db.delete(subAgentToolRelations).where(
     drizzleOrm.and(
-      drizzleOrm.eq(agentToolRelations.tenantId, params.scopes.tenantId),
-      drizzleOrm.eq(agentToolRelations.projectId, params.scopes.projectId),
-      drizzleOrm.eq(agentToolRelations.graphId, params.scopes.graphId),
-      drizzleOrm.eq(agentToolRelations.agentId, params.agentId),
-      drizzleOrm.eq(agentToolRelations.toolId, params.toolId)
+      drizzleOrm.eq(subAgentToolRelations.tenantId, params.scopes.tenantId),
+      drizzleOrm.eq(subAgentToolRelations.projectId, params.scopes.projectId),
+      drizzleOrm.eq(subAgentToolRelations.graphId, params.scopes.graphId),
+      drizzleOrm.eq(subAgentToolRelations.subAgentId, params.subAgentId),
+      drizzleOrm.eq(subAgentToolRelations.toolId, params.toolId)
     )
   ).returning();
   return deleted;
@@ -4693,7 +4924,7 @@ var upsertAgentToolRelation = (db) => async (params) => {
       scopes: params.scopes,
       relationId: params.relationId,
       data: {
-        agentId: params.agentId,
+        subAgentId: params.subAgentId,
         toolId: params.toolId,
         selectedTools: params.selectedTools,
         headers: params.headers
@@ -4736,7 +4967,7 @@ var getAgentGraphById = (db) => async (params) => {
   });
   return result ?? null;
 };
-var getAgentGraphWithDefaultAgent = (db) => async (params) => {
+var getAgentGraphWithDefaultSubAgent = (db) => async (params) => {
   const result = await db.query.agentGraph.findFirst({
     where: drizzleOrm.and(
       drizzleOrm.eq(agentGraph.tenantId, params.scopes.tenantId),
@@ -4744,7 +4975,7 @@ var getAgentGraphWithDefaultAgent = (db) => async (params) => {
       drizzleOrm.eq(agentGraph.id, params.scopes.graphId)
     ),
     with: {
-      defaultAgent: true
+      defaultSubAgent: true
     }
   });
   return result ?? null;
@@ -4849,14 +5080,14 @@ var deleteAgentGraph = (db) => async (params) => {
   ).returning();
   return result.length > 0;
 };
-var fetchComponentRelationships = (db) => async (scopes, agentIds, config) => {
+var fetchComponentRelationships = (db) => async (scopes, subAgentIds, config) => {
   const componentsObject = {};
-  if (agentIds.length > 0) {
+  if (subAgentIds.length > 0) {
     const results = await db.select(config.selectFields).from(config.relationTable).innerJoin(config.componentTable, drizzleOrm.eq(config.relationIdField, config.componentIdField)).where(
       drizzleOrm.and(
         drizzleOrm.eq(config.relationTable.tenantId, scopes.tenantId),
         drizzleOrm.eq(config.relationTable.projectId, scopes.projectId),
-        drizzleOrm.inArray(config.relationTable.agentId, agentIds)
+        drizzleOrm.inArray(config.subAgentIdField, subAgentIds)
       )
     );
     for (const component of results) {
@@ -4868,7 +5099,7 @@ var fetchComponentRelationships = (db) => async (scopes, agentIds, config) => {
 var getGraphAgentInfos = (db) => async ({
   scopes,
   graphId,
-  agentId
+  subAgentId
 }) => {
   const { tenantId, projectId } = scopes;
   const graph = await getAgentGraphById(db)({
@@ -4878,17 +5109,17 @@ var getGraphAgentInfos = (db) => async ({
     throw new Error(`Agent graph with ID ${graphId} not found for tenant ${tenantId}`);
   }
   const relations2 = await getAgentRelations(db)({
-    scopes: { tenantId, projectId, graphId, agentId }
+    scopes: { tenantId, projectId, graphId, subAgentId }
   });
-  const targetAgentIds = relations2.map((relation) => relation.targetAgentId).filter((id) => id !== null);
-  if (targetAgentIds.length === 0) {
+  const targetSubAgentIds = relations2.map((relation) => relation.targetSubAgentId).filter((id) => id !== null);
+  if (targetSubAgentIds.length === 0) {
     return [];
   }
   const agentInfos = await Promise.all(
-    targetAgentIds.map(async (targetAgentId) => {
-      const agent = await getAgentById(db)({
+    targetSubAgentIds.map(async (subAgentId2) => {
+      const agent = await getSubAgentById(db)({
         scopes: { tenantId, projectId, graphId },
-        agentId: targetAgentId
+        subAgentId: subAgentId2
       });
       if (agent !== void 0) {
         return { id: agent.id, name: agent.name, description: agent.description };
@@ -4910,28 +5141,28 @@ var getFullGraphDefinition = (db) => async ({
   const graphRelations = await getAgentRelationsByGraph(db)({
     scopes: { tenantId, projectId, graphId }
   });
-  const graphAgents = await db.query.agents.findMany({
+  const graphSubAgents = await db.query.subAgents.findMany({
     where: drizzleOrm.and(
-      drizzleOrm.eq(agents.tenantId, tenantId),
-      drizzleOrm.eq(agents.projectId, projectId),
-      drizzleOrm.eq(agents.graphId, graphId)
+      drizzleOrm.eq(subAgents.tenantId, tenantId),
+      drizzleOrm.eq(subAgents.projectId, projectId),
+      drizzleOrm.eq(subAgents.graphId, graphId)
     )
   });
-  const externalAgentIds = /* @__PURE__ */ new Set();
+  const externalSubAgentIds = /* @__PURE__ */ new Set();
   for (const relation of graphRelations) {
-    if (relation.externalAgentId) {
-      externalAgentIds.add(relation.externalAgentId);
+    if (relation.externalSubAgentId) {
+      externalSubAgentIds.add(relation.externalSubAgentId);
     }
   }
-  const processedAgents = await Promise.all(
-    graphAgents.map(async (agent) => {
+  const processedSubAgents = await Promise.all(
+    graphSubAgents.map(async (agent) => {
       if (!agent) return null;
-      const agentRelationsList = graphRelations.filter(
-        (relation) => relation.sourceAgentId === agent.id
+      const subAgentRelationsList = graphRelations.filter(
+        (relation) => relation.sourceSubAgentId === agent.id
       );
-      const canTransferTo = agentRelationsList.filter((rel) => rel.relationType === "transfer" || rel.relationType === "transfer_to").map((rel) => rel.targetAgentId).filter((id) => id !== null);
-      const canDelegateTo = agentRelationsList.filter((rel) => rel.relationType === "delegate" || rel.relationType === "delegate_to").map((rel) => rel.targetAgentId || rel.externalAgentId).filter((id) => id !== null);
-      const agentTools = await db.select({
+      const canTransferTo = subAgentRelationsList.filter((rel) => rel.relationType === "transfer" || rel.relationType === "transfer_to").map((rel) => rel.targetSubAgentId).filter((id) => id !== null);
+      const canDelegateTo = subAgentRelationsList.filter((rel) => rel.relationType === "delegate" || rel.relationType === "delegate_to").map((rel) => rel.targetSubAgentId || rel.externalSubAgentId).filter((id) => id !== null);
+      const subAgentTools = await db.select({
         id: tools.id,
         name: tools.name,
         config: tools.config,
@@ -4943,41 +5174,41 @@ var getFullGraphDefinition = (db) => async ({
         tenantId: tools.tenantId,
         projectId: tools.projectId,
         imageUrl: tools.imageUrl,
-        selectedTools: agentToolRelations.selectedTools,
-        headers: agentToolRelations.headers,
-        agentToolRelationId: agentToolRelations.id
-      }).from(agentToolRelations).innerJoin(
+        selectedTools: subAgentToolRelations.selectedTools,
+        headers: subAgentToolRelations.headers,
+        agentToolRelationId: subAgentToolRelations.id
+      }).from(subAgentToolRelations).innerJoin(
         tools,
         drizzleOrm.and(
-          drizzleOrm.eq(agentToolRelations.toolId, tools.id),
-          drizzleOrm.eq(agentToolRelations.tenantId, tools.tenantId),
-          drizzleOrm.eq(agentToolRelations.projectId, tools.projectId)
+          drizzleOrm.eq(subAgentToolRelations.toolId, tools.id),
+          drizzleOrm.eq(subAgentToolRelations.tenantId, tools.tenantId),
+          drizzleOrm.eq(subAgentToolRelations.projectId, tools.projectId)
         )
       ).where(
         drizzleOrm.and(
-          drizzleOrm.eq(agentToolRelations.tenantId, tenantId),
-          drizzleOrm.eq(agentToolRelations.projectId, projectId),
-          drizzleOrm.eq(agentToolRelations.graphId, graphId),
-          drizzleOrm.eq(agentToolRelations.agentId, agent.id)
+          drizzleOrm.eq(subAgentToolRelations.tenantId, tenantId),
+          drizzleOrm.eq(subAgentToolRelations.projectId, projectId),
+          drizzleOrm.eq(subAgentToolRelations.graphId, graphId),
+          drizzleOrm.eq(subAgentToolRelations.subAgentId, agent.id)
         )
       );
-      const agentDataComponentRelations = await db.query.agentDataComponents.findMany({
+      const agentDataComponentRelations = await db.query.subAgentDataComponents.findMany({
         where: drizzleOrm.and(
-          drizzleOrm.eq(agentDataComponents.tenantId, tenantId),
-          drizzleOrm.eq(agentDataComponents.agentId, agent.id)
+          drizzleOrm.eq(subAgentDataComponents.tenantId, tenantId),
+          drizzleOrm.eq(subAgentDataComponents.subAgentId, agent.id)
         )
       });
       const agentDataComponentIds = agentDataComponentRelations.map((rel) => rel.dataComponentId);
-      const agentArtifactComponentRelations = await db.query.agentArtifactComponents.findMany({
+      const agentArtifactComponentRelations = await db.query.subAgentArtifactComponents.findMany({
         where: drizzleOrm.and(
-          drizzleOrm.eq(agentArtifactComponents.tenantId, tenantId),
-          drizzleOrm.eq(agentArtifactComponents.agentId, agent.id)
+          drizzleOrm.eq(subAgentArtifactComponents.tenantId, tenantId),
+          drizzleOrm.eq(subAgentArtifactComponents.subAgentId, agent.id)
         )
       });
       const agentArtifactComponentIds = agentArtifactComponentRelations.map(
         (rel) => rel.artifactComponentId
       );
-      const canUse = agentTools.map((tool2) => ({
+      const canUse = subAgentTools.map((tool2) => ({
         agentToolRelationId: tool2.agentToolRelationId,
         toolId: tool2.id,
         toolSelection: tool2.selectedTools || null,
@@ -4999,24 +5230,24 @@ var getFullGraphDefinition = (db) => async ({
     })
   );
   const externalAgents2 = await Promise.all(
-    Array.from(externalAgentIds).map(async (agentId) => {
-      const agent = await getExternalAgent(db)({
+    Array.from(externalSubAgentIds).map(async (subAgentId) => {
+      const subAgent = await getExternalAgent(db)({
         scopes: { tenantId, projectId, graphId },
-        agentId
+        subAgentId
       });
-      if (!agent) return null;
+      if (!subAgent) return null;
       return {
-        id: agent.id,
-        name: agent.name,
-        description: agent.description,
-        baseUrl: agent.baseUrl,
-        headers: agent.headers,
-        credentialReferenceId: agent.credentialReferenceId,
+        id: subAgent.id,
+        name: subAgent.name,
+        description: subAgent.description,
+        baseUrl: subAgent.baseUrl,
+        headers: subAgent.headers,
+        credentialReferenceId: subAgent.credentialReferenceId,
         type: "external"
       };
     })
   );
-  const validAgents = [...processedAgents, ...externalAgents2].filter(
+  const validAgents = [...processedSubAgents, ...externalAgents2].filter(
     (agent) => agent !== null
   );
   const agentsObject = {};
@@ -5048,13 +5279,14 @@ var getFullGraphDefinition = (db) => async ({
     }
   }
   try {
-    const internalAgentIds = graphAgents.map((agent) => agent.id);
-    const agentIds = Array.from(internalAgentIds);
-    await fetchComponentRelationships(db)({ tenantId, projectId }, agentIds, {
-      relationTable: agentDataComponents,
+    const internalAgentIds = graphSubAgents.map((agent) => agent.id);
+    const subAgentIds = Array.from(internalAgentIds);
+    await fetchComponentRelationships(db)({ tenantId, projectId }, subAgentIds, {
+      relationTable: subAgentDataComponents,
       componentTable: dataComponents,
-      relationIdField: agentDataComponents.dataComponentId,
+      relationIdField: subAgentDataComponents.dataComponentId,
       componentIdField: dataComponents.id,
+      subAgentIdField: subAgentDataComponents.subAgentId,
       selectFields: {
         id: dataComponents.id,
         name: dataComponents.name,
@@ -5066,13 +5298,14 @@ var getFullGraphDefinition = (db) => async ({
     console.warn("Failed to retrieve dataComponents:", error);
   }
   try {
-    const internalAgentIds = graphAgents.map((agent) => agent.id);
-    const agentIds = Array.from(internalAgentIds);
-    await fetchComponentRelationships(db)({ tenantId, projectId }, agentIds, {
-      relationTable: agentArtifactComponents,
+    const internalAgentIds = graphSubAgents.map((agent) => agent.id);
+    const subAgentIds = Array.from(internalAgentIds);
+    await fetchComponentRelationships(db)({ tenantId, projectId }, subAgentIds, {
+      relationTable: subAgentArtifactComponents,
       componentTable: artifactComponents,
-      relationIdField: agentArtifactComponents.artifactComponentId,
+      relationIdField: subAgentArtifactComponents.artifactComponentId,
       componentIdField: artifactComponents.id,
+      subAgentIdField: subAgentArtifactComponents.subAgentId,
       selectFields: {
         id: artifactComponents.id,
         name: artifactComponents.name,
@@ -5087,8 +5320,8 @@ var getFullGraphDefinition = (db) => async ({
     id: graph.id,
     name: graph.name,
     description: graph.description,
-    defaultAgentId: graph.defaultAgentId,
-    agents: agentsObject,
+    defaultSubAgentId: graph.defaultSubAgentId,
+    subAgents: agentsObject,
     // No tools field - tools are defined at project level
     createdAt: graph.createdAt && !Number.isNaN(new Date(graph.createdAt).getTime()) ? new Date(graph.createdAt).toISOString() : (/* @__PURE__ */ new Date()).toISOString(),
     updatedAt: graph.updatedAt && !Number.isNaN(new Date(graph.updatedAt).getTime()) ? new Date(graph.updatedAt).toISOString() : (/* @__PURE__ */ new Date()).toISOString()
@@ -5122,7 +5355,7 @@ var getFullGraphDefinition = (db) => async ({
     if (project?.stopWhen) {
       const projectStopWhen = project.stopWhen;
       if (projectStopWhen?.stepCountIs !== void 0) {
-        for (const [agentId, agentData] of Object.entries(result.agents)) {
+        for (const [subAgentId, agentData] of Object.entries(result.subAgents)) {
           if (agentData && typeof agentData === "object" && !("baseUrl" in agentData)) {
             const agent = agentData;
             const needsInheritance = !agent.stopWhen || agent.stopWhen.stepCountIs === void 0;
@@ -5132,22 +5365,22 @@ var getFullGraphDefinition = (db) => async ({
               }
               agent.stopWhen.stepCountIs = projectStopWhen.stepCountIs;
               try {
-                await db.update(agents).set({
+                await db.update(subAgents).set({
                   stopWhen: agent.stopWhen,
                   updatedAt: (/* @__PURE__ */ new Date()).toISOString()
                 }).where(
                   drizzleOrm.and(
-                    drizzleOrm.eq(agents.tenantId, tenantId),
-                    drizzleOrm.eq(agents.projectId, projectId),
-                    drizzleOrm.eq(agents.id, agentId)
+                    drizzleOrm.eq(subAgents.tenantId, tenantId),
+                    drizzleOrm.eq(subAgents.projectId, projectId),
+                    drizzleOrm.eq(subAgents.id, subAgentId)
                   )
                 );
-                result.agents[agentId] = {
-                  ...result.agents[agentId],
+                result.subAgents[subAgentId] = {
+                  ...result.subAgents[subAgentId],
                   stopWhen: agent.stopWhen
                 };
               } catch (dbError) {
-                console.warn(`Failed to persist stopWhen for agent ${agentId}:`, dbError);
+                console.warn(`Failed to persist stopWhen for agent ${subAgentId}:`, dbError);
               }
             }
           }
@@ -5215,7 +5448,7 @@ var upsertAgentGraph = (db) => async (params) => {
       scopes,
       data: {
         name: params.data.name,
-        defaultAgentId: params.data.defaultAgentId,
+        defaultSubAgentId: params.data.defaultSubAgentId,
         description: params.data.description,
         contextConfigId: params.data.contextConfigId,
         models: params.data.models,
@@ -5597,24 +5830,24 @@ var getArtifactComponentsForAgent = (db) => async (params) => {
     createdAt: artifactComponents.createdAt,
     updatedAt: artifactComponents.updatedAt
   }).from(artifactComponents).innerJoin(
-    agentArtifactComponents,
-    drizzleOrm.eq(artifactComponents.id, agentArtifactComponents.artifactComponentId)
+    subAgentArtifactComponents,
+    drizzleOrm.eq(artifactComponents.id, subAgentArtifactComponents.artifactComponentId)
   ).where(
     drizzleOrm.and(
       drizzleOrm.eq(artifactComponents.tenantId, params.scopes.tenantId),
       drizzleOrm.eq(artifactComponents.projectId, params.scopes.projectId),
-      drizzleOrm.eq(agentArtifactComponents.graphId, params.scopes.graphId),
-      drizzleOrm.eq(agentArtifactComponents.agentId, params.scopes.agentId)
+      drizzleOrm.eq(subAgentArtifactComponents.graphId, params.scopes.graphId),
+      drizzleOrm.eq(subAgentArtifactComponents.subAgentId, params.scopes.subAgentId)
     )
   ).orderBy(drizzleOrm.desc(artifactComponents.createdAt));
 };
 var associateArtifactComponentWithAgent = (db) => async (params) => {
-  const [association] = await db.insert(agentArtifactComponents).values({
+  const [association] = await db.insert(subAgentArtifactComponents).values({
     id: nanoid.nanoid(),
     tenantId: params.scopes.tenantId,
     projectId: params.scopes.projectId,
     graphId: params.scopes.graphId,
-    agentId: params.scopes.agentId,
+    subAgentId: params.scopes.subAgentId,
     artifactComponentId: params.artifactComponentId,
     createdAt: (/* @__PURE__ */ new Date()).toISOString()
   }).returning();
@@ -5622,13 +5855,13 @@ var associateArtifactComponentWithAgent = (db) => async (params) => {
 };
 var removeArtifactComponentFromAgent = (db) => async (params) => {
   try {
-    const result = await db.delete(agentArtifactComponents).where(
+    const result = await db.delete(subAgentArtifactComponents).where(
       drizzleOrm.and(
-        drizzleOrm.eq(agentArtifactComponents.tenantId, params.scopes.tenantId),
-        drizzleOrm.eq(agentArtifactComponents.projectId, params.scopes.projectId),
-        drizzleOrm.eq(agentArtifactComponents.graphId, params.scopes.graphId),
-        drizzleOrm.eq(agentArtifactComponents.agentId, params.scopes.agentId),
-        drizzleOrm.eq(agentArtifactComponents.artifactComponentId, params.artifactComponentId)
+        drizzleOrm.eq(subAgentArtifactComponents.tenantId, params.scopes.tenantId),
+        drizzleOrm.eq(subAgentArtifactComponents.projectId, params.scopes.projectId),
+        drizzleOrm.eq(subAgentArtifactComponents.graphId, params.scopes.graphId),
+        drizzleOrm.eq(subAgentArtifactComponents.subAgentId, params.scopes.subAgentId),
+        drizzleOrm.eq(subAgentArtifactComponents.artifactComponentId, params.artifactComponentId)
       )
     ).returning();
     return result.length > 0;
@@ -5638,60 +5871,60 @@ var removeArtifactComponentFromAgent = (db) => async (params) => {
   }
 };
 var deleteAgentArtifactComponentRelationByAgent = (db) => async (params) => {
-  const result = await db.delete(agentArtifactComponents).where(
+  const result = await db.delete(subAgentArtifactComponents).where(
     drizzleOrm.and(
-      drizzleOrm.eq(agentArtifactComponents.tenantId, params.scopes.tenantId),
-      drizzleOrm.eq(agentArtifactComponents.graphId, params.scopes.graphId),
-      drizzleOrm.eq(agentArtifactComponents.agentId, params.scopes.agentId)
+      drizzleOrm.eq(subAgentArtifactComponents.tenantId, params.scopes.tenantId),
+      drizzleOrm.eq(subAgentArtifactComponents.graphId, params.scopes.graphId),
+      drizzleOrm.eq(subAgentArtifactComponents.subAgentId, params.scopes.subAgentId)
     )
   );
   return (result.rowsAffected || 0) > 0;
 };
 var getAgentsUsingArtifactComponent = (db) => async (params) => {
   return await db.select({
-    graphId: agentArtifactComponents.graphId,
-    agentId: agentArtifactComponents.agentId,
-    createdAt: agentArtifactComponents.createdAt
-  }).from(agentArtifactComponents).where(
+    graphId: subAgentArtifactComponents.graphId,
+    subAgentId: subAgentArtifactComponents.subAgentId,
+    createdAt: subAgentArtifactComponents.createdAt
+  }).from(subAgentArtifactComponents).where(
     drizzleOrm.and(
-      drizzleOrm.eq(agentArtifactComponents.tenantId, params.scopes.tenantId),
-      drizzleOrm.eq(agentArtifactComponents.projectId, params.scopes.projectId),
-      drizzleOrm.eq(agentArtifactComponents.artifactComponentId, params.artifactComponentId)
+      drizzleOrm.eq(subAgentArtifactComponents.tenantId, params.scopes.tenantId),
+      drizzleOrm.eq(subAgentArtifactComponents.projectId, params.scopes.projectId),
+      drizzleOrm.eq(subAgentArtifactComponents.artifactComponentId, params.artifactComponentId)
     )
-  ).orderBy(drizzleOrm.desc(agentArtifactComponents.createdAt));
+  ).orderBy(drizzleOrm.desc(subAgentArtifactComponents.createdAt));
 };
 var isArtifactComponentAssociatedWithAgent = (db) => async (params) => {
-  const result = await db.select({ id: agentArtifactComponents.id }).from(agentArtifactComponents).where(
+  const result = await db.select({ id: subAgentArtifactComponents.id }).from(subAgentArtifactComponents).where(
     drizzleOrm.and(
-      drizzleOrm.eq(agentArtifactComponents.tenantId, params.scopes.tenantId),
-      drizzleOrm.eq(agentArtifactComponents.projectId, params.scopes.projectId),
-      drizzleOrm.eq(agentArtifactComponents.graphId, params.scopes.graphId),
-      drizzleOrm.eq(agentArtifactComponents.agentId, params.scopes.agentId),
-      drizzleOrm.eq(agentArtifactComponents.artifactComponentId, params.artifactComponentId)
+      drizzleOrm.eq(subAgentArtifactComponents.tenantId, params.scopes.tenantId),
+      drizzleOrm.eq(subAgentArtifactComponents.projectId, params.scopes.projectId),
+      drizzleOrm.eq(subAgentArtifactComponents.graphId, params.scopes.graphId),
+      drizzleOrm.eq(subAgentArtifactComponents.subAgentId, params.scopes.subAgentId),
+      drizzleOrm.eq(subAgentArtifactComponents.artifactComponentId, params.artifactComponentId)
     )
   ).limit(1);
   return result.length > 0;
 };
 var graphHasArtifactComponents = (db) => async (params) => {
-  const result = await db.select({ count: drizzleOrm.count() }).from(agentArtifactComponents).innerJoin(
-    agents,
+  const result = await db.select({ count: drizzleOrm.count() }).from(subAgentArtifactComponents).innerJoin(
+    subAgents,
     drizzleOrm.and(
-      drizzleOrm.eq(agentArtifactComponents.agentId, agents.id),
-      drizzleOrm.eq(agentArtifactComponents.tenantId, agents.tenantId)
+      drizzleOrm.eq(subAgentArtifactComponents.subAgentId, subAgents.id),
+      drizzleOrm.eq(subAgentArtifactComponents.tenantId, subAgents.tenantId)
     )
   ).innerJoin(
-    agentRelations,
+    subAgentRelations,
     drizzleOrm.and(
-      drizzleOrm.eq(agents.id, agentRelations.sourceAgentId),
-      drizzleOrm.eq(agents.tenantId, agentRelations.tenantId),
-      drizzleOrm.eq(agents.projectId, agentRelations.projectId),
-      drizzleOrm.eq(agents.graphId, agentRelations.graphId)
+      drizzleOrm.eq(subAgents.id, subAgentRelations.sourceSubAgentId),
+      drizzleOrm.eq(subAgents.tenantId, subAgentRelations.tenantId),
+      drizzleOrm.eq(subAgents.projectId, subAgentRelations.projectId),
+      drizzleOrm.eq(subAgents.graphId, subAgentRelations.graphId)
     )
   ).where(
     drizzleOrm.and(
-      drizzleOrm.eq(agentArtifactComponents.tenantId, params.scopes.tenantId),
-      drizzleOrm.eq(agentArtifactComponents.projectId, params.scopes.projectId),
-      drizzleOrm.eq(agentRelations.graphId, params.scopes.graphId)
+      drizzleOrm.eq(subAgentArtifactComponents.tenantId, params.scopes.tenantId),
+      drizzleOrm.eq(subAgentArtifactComponents.projectId, params.scopes.projectId),
+      drizzleOrm.eq(subAgentRelations.graphId, params.scopes.graphId)
     )
   ).limit(1);
   const total = result[0]?.count || 0;
@@ -5709,12 +5942,12 @@ var countArtifactComponents = (db) => async (params) => {
   return typeof total === "string" ? Number.parseInt(total, 10) : total;
 };
 var countArtifactComponentsForAgent = (db) => async (params) => {
-  const result = await db.select({ count: drizzleOrm.count() }).from(agentArtifactComponents).where(
+  const result = await db.select({ count: drizzleOrm.count() }).from(subAgentArtifactComponents).where(
     drizzleOrm.and(
-      drizzleOrm.eq(agentArtifactComponents.tenantId, params.scopes.tenantId),
-      drizzleOrm.eq(agentArtifactComponents.projectId, params.scopes.projectId),
-      drizzleOrm.eq(agentArtifactComponents.graphId, params.scopes.graphId),
-      drizzleOrm.eq(agentArtifactComponents.agentId, params.scopes.agentId)
+      drizzleOrm.eq(subAgentArtifactComponents.tenantId, params.scopes.tenantId),
+      drizzleOrm.eq(subAgentArtifactComponents.projectId, params.scopes.projectId),
+      drizzleOrm.eq(subAgentArtifactComponents.graphId, params.scopes.graphId),
+      drizzleOrm.eq(subAgentArtifactComponents.subAgentId, params.scopes.subAgentId)
     )
   );
   const total = result[0]?.count || 0;
@@ -5949,7 +6182,7 @@ var updateConversationActiveAgent = (db) => async (params) => {
     scopes: params.scopes,
     conversationId: params.conversationId,
     data: {
-      activeAgentId: params.activeAgentId
+      activeSubAgentId: params.activeSubAgentId
     }
   });
 };
@@ -5969,12 +6202,12 @@ var createOrGetConversation = (db) => async (input) => {
       where: drizzleOrm.and(drizzleOrm.eq(conversations.tenantId, input.tenantId), drizzleOrm.eq(conversations.id, input.id))
     });
     if (existing) {
-      if (existing.activeAgentId !== input.activeAgentId) {
+      if (existing.activeSubAgentId !== input.activeSubAgentId) {
         await db.update(conversations).set({
-          activeAgentId: input.activeAgentId,
+          activeSubAgentId: input.activeSubAgentId,
           updatedAt: (/* @__PURE__ */ new Date()).toISOString()
         }).where(drizzleOrm.eq(conversations.id, input.id));
-        return { ...existing, activeAgentId: input.activeAgentId };
+        return { ...existing, activeSubAgentId: input.activeSubAgentId };
       }
       return existing;
     }
@@ -5984,7 +6217,7 @@ var createOrGetConversation = (db) => async (input) => {
     tenantId: input.tenantId,
     projectId: input.projectId,
     userId: input.userId,
-    activeAgentId: input.activeAgentId,
+    activeSubAgentId: input.activeSubAgentId,
     title: input.title,
     lastContextResolution: input.lastContextResolution,
     metadata: input.metadata,
@@ -6070,13 +6303,13 @@ var setActiveAgentForConversation = (db) => async (params) => {
     id: params.conversationId,
     tenantId: params.scopes.tenantId,
     projectId: params.scopes.projectId,
-    activeAgentId: params.agentId,
+    activeSubAgentId: params.subAgentId,
     createdAt: (/* @__PURE__ */ new Date()).toISOString(),
     updatedAt: (/* @__PURE__ */ new Date()).toISOString()
   }).onConflictDoUpdate({
     target: [conversations.tenantId, conversations.projectId, conversations.id],
     set: {
-      activeAgentId: params.agentId,
+      activeSubAgentId: params.subAgentId,
       updatedAt: (/* @__PURE__ */ new Date()).toISOString()
     }
   });
@@ -6084,9 +6317,13 @@ var setActiveAgentForConversation = (db) => async (params) => {
 var setActiveAgentForThread = (db) => async ({
   scopes,
   threadId,
-  agentId
+  subAgentId
 }) => {
-  return setActiveAgentForConversation(db)({ scopes, conversationId: threadId, agentId });
+  return setActiveAgentForConversation(db)({
+    scopes,
+    conversationId: threadId,
+    subAgentId
+  });
 };
 var getDataComponent = (db) => async (params) => {
   const result = await db.query.dataComponents.findFirst({
@@ -6186,68 +6423,71 @@ var getDataComponentsForAgent = (db) => async (params) => {
     props: dataComponents.props,
     createdAt: dataComponents.createdAt,
     updatedAt: dataComponents.updatedAt
-  }).from(dataComponents).innerJoin(agentDataComponents, drizzleOrm.eq(dataComponents.id, agentDataComponents.dataComponentId)).where(
+  }).from(dataComponents).innerJoin(
+    subAgentDataComponents,
+    drizzleOrm.eq(dataComponents.id, subAgentDataComponents.dataComponentId)
+  ).where(
     drizzleOrm.and(
       drizzleOrm.eq(dataComponents.tenantId, params.scopes.tenantId),
       drizzleOrm.eq(dataComponents.projectId, params.scopes.projectId),
-      drizzleOrm.eq(agentDataComponents.graphId, params.scopes.graphId),
-      drizzleOrm.eq(agentDataComponents.agentId, params.scopes.agentId)
+      drizzleOrm.eq(subAgentDataComponents.graphId, params.scopes.graphId),
+      drizzleOrm.eq(subAgentDataComponents.subAgentId, params.scopes.subAgentId)
     )
   ).orderBy(drizzleOrm.desc(dataComponents.createdAt));
 };
 var associateDataComponentWithAgent = (db) => async (params) => {
-  const association = await db.insert(agentDataComponents).values({
+  const association = await db.insert(subAgentDataComponents).values({
     id: nanoid.nanoid(),
     tenantId: params.scopes.tenantId,
     projectId: params.scopes.projectId,
     graphId: params.scopes.graphId,
-    agentId: params.scopes.agentId,
+    subAgentId: params.scopes.subAgentId,
     dataComponentId: params.dataComponentId
   }).returning();
   return association[0];
 };
 var removeDataComponentFromAgent = (db) => async (params) => {
-  const result = await db.delete(agentDataComponents).where(
+  const result = await db.delete(subAgentDataComponents).where(
     drizzleOrm.and(
-      drizzleOrm.eq(agentDataComponents.tenantId, params.scopes.tenantId),
-      drizzleOrm.eq(agentDataComponents.projectId, params.scopes.projectId),
-      drizzleOrm.eq(agentDataComponents.graphId, params.scopes.graphId),
-      drizzleOrm.eq(agentDataComponents.agentId, params.scopes.agentId),
-      drizzleOrm.eq(agentDataComponents.dataComponentId, params.dataComponentId)
+      drizzleOrm.eq(subAgentDataComponents.tenantId, params.scopes.tenantId),
+      drizzleOrm.eq(subAgentDataComponents.projectId, params.scopes.projectId),
+      drizzleOrm.eq(subAgentDataComponents.graphId, params.scopes.graphId),
+      drizzleOrm.eq(subAgentDataComponents.subAgentId, params.scopes.subAgentId),
+      drizzleOrm.eq(subAgentDataComponents.dataComponentId, params.dataComponentId)
     )
   ).returning();
   return result.length > 0;
 };
 var deleteAgentDataComponentRelationByAgent = (db) => async (params) => {
-  const result = await db.delete(agentDataComponents).where(
+  const result = await db.delete(subAgentDataComponents).where(
     drizzleOrm.and(
-      drizzleOrm.eq(agentDataComponents.tenantId, params.scopes.tenantId),
-      drizzleOrm.eq(agentDataComponents.graphId, params.scopes.graphId),
-      drizzleOrm.eq(agentDataComponents.agentId, params.scopes.agentId)
+      drizzleOrm.eq(subAgentDataComponents.tenantId, params.scopes.tenantId),
+      drizzleOrm.eq(subAgentDataComponents.graphId, params.scopes.graphId),
+      drizzleOrm.eq(subAgentDataComponents.subAgentId, params.scopes.subAgentId)
     )
   );
   return (result.rowsAffected || 0) > 0;
 };
 var getAgentsUsingDataComponent = (db) => async (params) => {
   return await db.select({
-    agentId: agentDataComponents.agentId,
-    createdAt: agentDataComponents.createdAt
-  }).from(agentDataComponents).where(
+    subAgentId: subAgentDataComponents.subAgentId,
+    createdAt: subAgentDataComponents.createdAt
+  }).from(subAgentDataComponents).where(
     drizzleOrm.and(
-      drizzleOrm.eq(agentDataComponents.tenantId, params.scopes.tenantId),
-      drizzleOrm.eq(agentDataComponents.projectId, params.scopes.projectId),
-      drizzleOrm.eq(agentDataComponents.dataComponentId, params.dataComponentId)
+      drizzleOrm.eq(subAgentDataComponents.tenantId, params.scopes.tenantId),
+      drizzleOrm.eq(subAgentDataComponents.projectId, params.scopes.projectId),
+      drizzleOrm.eq(subAgentDataComponents.dataComponentId, params.dataComponentId)
     )
-  ).orderBy(drizzleOrm.desc(agentDataComponents.createdAt));
+  ).orderBy(drizzleOrm.desc(subAgentDataComponents.createdAt));
 };
 var isDataComponentAssociatedWithAgent = (db) => async (params) => {
-  const result = await db.select({ id: agentDataComponents.id }).from(agentDataComponents).where(
+  const result = await db.select({ id: subAgentDataComponents.id }).from(subAgentDataComponents).where(
     drizzleOrm.and(
-      drizzleOrm.eq(agentDataComponents.tenantId, params.scopes.tenantId),
-      drizzleOrm.eq(agentDataComponents.projectId, params.scopes.projectId),
-      drizzleOrm.eq(agentDataComponents.graphId, params.scopes.graphId),
-      drizzleOrm.eq(agentDataComponents.agentId, params.scopes.agentId),
-      drizzleOrm.eq(agentDataComponents.dataComponentId, params.dataComponentId)
+      drizzleOrm.eq(subAgentDataComponents.tenantId, params.scopes.tenantId),
+      drizzleOrm.eq(subAgentDataComponents.projectId, params.scopes.projectId),
+      drizzleOrm.eq(subAgentDataComponents.graphId, params.scopes.graphId),
+      drizzleOrm.eq(subAgentDataComponents.subAgentId, params.scopes.subAgentId),
+      drizzleOrm.eq(subAgentDataComponents.dataComponentId, params.dataComponentId)
     )
   ).limit(1);
   return result.length > 0;
@@ -6298,18 +6538,18 @@ function isExternalAgent(agent) {
   return "baseUrl" in agent;
 }
 function validateAndTypeGraphData(data) {
-  return FullGraphDefinitionSchema.parse(data);
+  return GraphWithinContextOfProjectSchema.parse(data);
 }
 function validateToolReferences(graphData, availableToolIds) {
   if (!availableToolIds) {
     return;
   }
   const errors = [];
-  for (const [agentId, agentData] of Object.entries(graphData.agents)) {
+  for (const [subAgentId, agentData] of Object.entries(graphData.subAgents)) {
     if (isInternalAgent(agentData) && agentData.canUse && Array.isArray(agentData.canUse)) {
       for (const canUseItem of agentData.canUse) {
         if (!availableToolIds.has(canUseItem.toolId)) {
-          errors.push(`Agent '${agentId}' references non-existent tool '${canUseItem.toolId}'`);
+          errors.push(`Agent '${subAgentId}' references non-existent tool '${canUseItem.toolId}'`);
         }
       }
     }
@@ -6324,12 +6564,12 @@ function validateDataComponentReferences(graphData, availableDataComponentIds) {
     return;
   }
   const errors = [];
-  for (const [agentId, agentData] of Object.entries(graphData.agents)) {
+  for (const [subAgentId, agentData] of Object.entries(graphData.subAgents)) {
     if (isInternalAgent(agentData) && agentData.dataComponents) {
       for (const dataComponentId of agentData.dataComponents) {
         if (!availableDataComponentIds.has(dataComponentId)) {
           errors.push(
-            `Agent '${agentId}' references non-existent dataComponent '${dataComponentId}'`
+            `Agent '${subAgentId}' references non-existent dataComponent '${dataComponentId}'`
           );
         }
       }
@@ -6345,12 +6585,12 @@ function validateArtifactComponentReferences(graphData, availableArtifactCompone
     return;
   }
   const errors = [];
-  for (const [agentId, agentData] of Object.entries(graphData.agents)) {
+  for (const [subAgentId, agentData] of Object.entries(graphData.subAgents)) {
     if (isInternalAgent(agentData) && agentData.artifactComponents) {
       for (const artifactComponentId of agentData.artifactComponents) {
         if (!availableArtifactComponentIds.has(artifactComponentId)) {
           errors.push(
-            `Agent '${agentId}' references non-existent artifactComponent '${artifactComponentId}'`
+            `Agent '${subAgentId}' references non-existent artifactComponent '${artifactComponentId}'`
           );
         }
       }
@@ -6363,14 +6603,14 @@ ${errors.join("\n")}`);
 }
 function validateAgentRelationships(graphData) {
   const errors = [];
-  const availableAgentIds = new Set(Object.keys(graphData.agents));
-  for (const [agentId, agentData] of Object.entries(graphData.agents)) {
+  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) {
           if (!availableAgentIds.has(targetId)) {
             errors.push(
-              `Agent '${agentId}' has transfer target '${targetId}' that doesn't exist in graph`
+              `Agent '${subAgentId}' has transfer target '${targetId}' that doesn't exist in graph`
             );
           }
         }
@@ -6379,7 +6619,7 @@ function validateAgentRelationships(graphData) {
         for (const targetId of agentData.canDelegateTo) {
           if (!availableAgentIds.has(targetId)) {
             errors.push(
-              `Agent '${agentId}' has delegation target '${targetId}' that doesn't exist in graph`
+              `Agent '${subAgentId}' has delegation target '${targetId}' that doesn't exist in graph`
             );
           }
         }
@@ -6392,8 +6632,8 @@ ${errors.join("\n")}`);
   }
 }
 function validateGraphStructure(graphData, projectResources) {
-  if (graphData.defaultAgentId && !graphData.agents[graphData.defaultAgentId]) {
-    throw new Error(`Default agent '${graphData.defaultAgentId}' does not exist in agents`);
+  if (graphData.defaultSubAgentId && !graphData.subAgents[graphData.defaultSubAgentId]) {
+    throw new Error(`Default agent '${graphData.defaultSubAgentId}' does not exist in agents`);
   }
   if (projectResources) {
     validateToolReferences(graphData, projectResources.toolIds);
@@ -6459,7 +6699,7 @@ async function applyExecutionLimitsInheritance(db, logger13, scopes, graphData)
         },
         "Propagating stepCountIs to agents"
       );
-      for (const [agentId, agentData] of Object.entries(graphData.agents)) {
+      for (const [subAgentId, agentData] of Object.entries(graphData.subAgents)) {
         if (isInternalAgent(agentData)) {
           const agent = agentData;
           if (!agent.stopWhen) {
@@ -6469,7 +6709,7 @@ async function applyExecutionLimitsInheritance(db, logger13, scopes, graphData)
             agent.stopWhen.stepCountIs = projectStopWhen.stepCountIs;
             logger13.info(
               {
-                agentId,
+                subAgentId,
                 inheritedValue: projectStopWhen.stepCountIs
               },
               "Agent inherited stepCountIs from project"
@@ -6509,7 +6749,7 @@ var createFullGraphServerSide = (db, logger13 = defaultLogger) => async (scopes,
           tenantId,
           projectId,
           name: typed.name,
-          defaultAgentId: typed.defaultAgentId,
+          defaultSubAgentId: typed.defaultSubAgentId,
           description: typed.description,
           contextConfigId: void 0,
           // Will be updated later if context config exists
@@ -6559,7 +6799,7 @@ var createFullGraphServerSide = (db, logger13 = defaultLogger) => async (scopes,
             tenantId,
             projectId,
             name: typed.name,
-            defaultAgentId: typed.defaultAgentId,
+            defaultSubAgentId: typed.defaultSubAgentId,
             description: typed.description,
             contextConfigId,
             models: typed.models,
@@ -6588,13 +6828,13 @@ var createFullGraphServerSide = (db, logger13 = defaultLogger) => async (scopes,
       {},
       "ArtifactComponents are project-scoped - skipping artifactComponent creation in graph"
     );
-    const internalAgentPromises = Object.entries(typed.agents).filter(([_, agentData]) => isInternalAgent(agentData)).map(async ([agentId, agentData]) => {
+    const internalAgentPromises = Object.entries(typed.subAgents).filter(([_, agentData]) => isInternalAgent(agentData)).map(async ([subAgentId, agentData]) => {
       const internalAgent = agentData;
       try {
-        logger13.info({ agentId }, "Processing internal agent");
-        await upsertAgent(db)({
+        logger13.info({ subAgentId }, "Processing internal agent");
+        await upsertSubAgent(db)({
           data: {
-            id: agentId,
+            id: subAgentId,
             tenantId,
             projectId,
             graphId: finalGraphId,
@@ -6606,24 +6846,24 @@ var createFullGraphServerSide = (db, logger13 = defaultLogger) => async (scopes,
             stopWhen: internalAgent.stopWhen
           }
         });
-        logger13.info({ agentId }, "Internal agent processed successfully");
+        logger13.info({ subAgentId }, "Internal agent processed successfully");
       } catch (error) {
-        logger13.error({ agentId, error }, "Failed to create/update internal agent");
+        logger13.error({ subAgentId, error }, "Failed to create/update internal agent");
         throw error;
       }
     });
     await Promise.all(internalAgentPromises);
-    const internalAgentCount = Object.entries(typed.agents).filter(
+    const internalAgentCount = Object.entries(typed.subAgents).filter(
       ([_, agentData]) => isInternalAgent(agentData)
     ).length;
     logger13.info({ internalAgentCount }, "All internal agents created/updated successfully");
-    const externalAgentPromises = Object.entries(typed.agents).filter(([_, agentData]) => isExternalAgent(agentData)).map(async ([agentId, agentData]) => {
+    const externalAgentPromises = Object.entries(typed.subAgents).filter(([_, agentData]) => isExternalAgent(agentData)).map(async ([subAgentId, agentData]) => {
       const externalAgent = agentData;
       try {
-        logger13.info({ agentId }, "Processing external agent");
+        logger13.info({ subAgentId }, "Processing external agent");
         await upsertExternalAgent(db)({
           data: {
-            id: agentId,
+            id: subAgentId,
             tenantId,
             projectId,
             graphId: finalGraphId,
@@ -6634,14 +6874,14 @@ var createFullGraphServerSide = (db, logger13 = defaultLogger) => async (scopes,
             headers: externalAgent.headers || void 0
           }
         });
-        logger13.info({ agentId }, "External agent processed successfully");
+        logger13.info({ subAgentId }, "External agent processed successfully");
       } catch (error) {
-        logger13.error({ agentId, error }, "Failed to create/update external agent");
+        logger13.error({ subAgentId, error }, "Failed to create/update external agent");
         throw error;
       }
     });
     await Promise.all(externalAgentPromises);
-    const externalAgentCount = Object.entries(typed.agents).filter(
+    const externalAgentCount = Object.entries(typed.subAgents).filter(
       ([_, agentData]) => isExternalAgent(agentData)
     ).length;
     logger13.info({ externalAgentCount }, "All external agents created/updated successfully");
@@ -6665,26 +6905,26 @@ var createFullGraphServerSide = (db, logger13 = defaultLogger) => async (scopes,
       }
     }
     const agentToolPromises = [];
-    for (const [agentId, agentData] of Object.entries(typed.agents)) {
+    for (const [subAgentId, agentData] of Object.entries(typed.subAgents)) {
       if (isInternalAgent(agentData) && agentData.canUse && Array.isArray(agentData.canUse)) {
         for (const canUseItem of agentData.canUse) {
           agentToolPromises.push(
             (async () => {
               try {
                 const { toolId, toolSelection, headers: headers2, agentToolRelationId } = canUseItem;
-                logger13.info({ agentId, toolId }, "Processing agent-tool relation");
+                logger13.info({ subAgentId, toolId }, "Processing agent-tool relation");
                 await upsertAgentToolRelation(db)({
                   scopes: { tenantId, projectId, graphId: finalGraphId },
-                  agentId,
+                  subAgentId,
                   toolId,
                   selectedTools: toolSelection || void 0,
                   headers: headers2 || void 0,
                   relationId: agentToolRelationId
                 });
-                logger13.info({ agentId, toolId }, "Agent-tool relation processed successfully");
+                logger13.info({ subAgentId, toolId }, "Agent-tool relation processed successfully");
               } catch (error) {
                 logger13.error(
-                  { agentId, toolId: canUseItem.toolId, error },
+                  { subAgentId, toolId: canUseItem.toolId, error },
                   "Failed to create agent-tool relation"
                 );
               }
@@ -6695,31 +6935,31 @@ var createFullGraphServerSide = (db, logger13 = defaultLogger) => async (scopes,
     }
     await Promise.all(agentToolPromises);
     logger13.info(
-      { agentToolCount: Object.keys(typed.agents).length },
+      { agentToolCount: Object.keys(typed.subAgents).length },
       "All agent-tool relations created"
     );
     const agentDataComponentPromises = [];
-    for (const [agentId, agentData] of Object.entries(typed.agents)) {
+    for (const [subAgentId, agentData] of Object.entries(typed.subAgents)) {
       if (isInternalAgent(agentData) && agentData.dataComponents) {
         for (const dataComponentId of agentData.dataComponents) {
           agentDataComponentPromises.push(
             (async () => {
               try {
                 logger13.info(
-                  { agentId, dataComponentId },
+                  { subAgentId, dataComponentId },
                   "Processing agent-data component relation"
                 );
                 await upsertAgentDataComponentRelation(db)({
-                  scopes: { tenantId, projectId, graphId: finalGraphId, agentId },
+                  scopes: { tenantId, projectId, graphId: finalGraphId, subAgentId },
                   dataComponentId
                 });
                 logger13.info(
-                  { agentId, dataComponentId },
+                  { subAgentId, dataComponentId },
                   "Agent-data component relation processed successfully"
                 );
               } catch (error) {
                 logger13.error(
-                  { agentId, dataComponentId, error },
+                  { subAgentId, dataComponentId, error },
                   "Failed to create agent-data component relation"
                 );
               }
@@ -6731,27 +6971,27 @@ var createFullGraphServerSide = (db, logger13 = defaultLogger) => async (scopes,
     await Promise.all(agentDataComponentPromises);
     logger13.info({}, "All agent-data component relations created");
     const agentArtifactComponentPromises = [];
-    for (const [agentId, agentData] of Object.entries(typed.agents)) {
+    for (const [subAgentId, agentData] of Object.entries(typed.subAgents)) {
       if (isInternalAgent(agentData) && agentData.artifactComponents) {
         for (const artifactComponentId of agentData.artifactComponents) {
           agentArtifactComponentPromises.push(
             (async () => {
               try {
                 logger13.info(
-                  { agentId, artifactComponentId },
+                  { subAgentId, artifactComponentId },
                   "Processing agent-artifact component relation"
                 );
                 await upsertAgentArtifactComponentRelation(db)({
-                  scopes: { tenantId, projectId, graphId: finalGraphId, agentId },
+                  scopes: { tenantId, projectId, graphId: finalGraphId, subAgentId },
                   artifactComponentId
                 });
                 logger13.info(
-                  { agentId, artifactComponentId },
+                  { subAgentId, artifactComponentId },
                   "Agent-artifact component relation processed successfully"
                 );
               } catch (error) {
                 logger13.error(
-                  { agentId, artifactComponentId, error },
+                  { subAgentId, artifactComponentId, error },
                   "Failed to create agent-artifact component relation"
                 );
               }
@@ -6763,14 +7003,14 @@ var createFullGraphServerSide = (db, logger13 = defaultLogger) => async (scopes,
     await Promise.all(agentArtifactComponentPromises);
     logger13.info({}, "All agent-artifact component relations created");
     const agentRelationPromises = [];
-    for (const [agentId, agentData] of Object.entries(typed.agents)) {
+    for (const [subAgentId, agentData] of Object.entries(typed.subAgents)) {
       if (isInternalAgent(agentData) && agentData.canTransferTo) {
-        for (const targetAgentId of agentData.canTransferTo) {
+        for (const targetSubAgentId of agentData.canTransferTo) {
           agentRelationPromises.push(
             (async () => {
               try {
                 logger13.info(
-                  { agentId, targetAgentId, type: "transfer" },
+                  { subAgentId, targetSubAgentId, type: "transfer" },
                   "Processing agent transfer relation"
                 );
                 await upsertAgentRelation(db)({
@@ -6778,17 +7018,17 @@ var createFullGraphServerSide = (db, logger13 = defaultLogger) => async (scopes,
                   tenantId,
                   projectId,
                   graphId: finalGraphId,
-                  sourceAgentId: agentId,
-                  targetAgentId,
+                  sourceSubAgentId: subAgentId,
+                  targetSubAgentId,
                   relationType: "transfer"
                 });
                 logger13.info(
-                  { agentId, targetAgentId, type: "transfer" },
+                  { subAgentId, targetSubAgentId, type: "transfer" },
                   "Agent transfer relation processed successfully"
                 );
               } catch (error) {
                 logger13.error(
-                  { agentId, targetAgentId, type: "transfer", error },
+                  { subAgentId, targetSubAgentId, type: "transfer", error },
                   "Failed to create transfer relation"
                 );
               }
@@ -6797,14 +7037,14 @@ var createFullGraphServerSide = (db, logger13 = defaultLogger) => async (scopes,
         }
       }
       if (isInternalAgent(agentData) && agentData.canDelegateTo) {
-        for (const targetAgentId of agentData.canDelegateTo) {
-          const targetAgentData = typed.agents[targetAgentId];
+        for (const targetSubAgentId of agentData.canDelegateTo) {
+          const targetAgentData = typed.subAgents[targetSubAgentId];
           const isTargetExternal = isExternalAgent(targetAgentData);
           agentRelationPromises.push(
             (async () => {
               try {
                 logger13.info(
-                  { agentId, targetAgentId, type: "delegate" },
+                  { subAgentId, targetSubAgentId, type: "delegate" },
                   "Processing agent delegation relation"
                 );
                 await upsertAgentRelation(db)({
@@ -6812,18 +7052,18 @@ var createFullGraphServerSide = (db, logger13 = defaultLogger) => async (scopes,
                   tenantId,
                   projectId,
                   graphId: finalGraphId,
-                  sourceAgentId: agentId,
-                  targetAgentId: isTargetExternal ? void 0 : targetAgentId,
-                  externalAgentId: isTargetExternal ? targetAgentId : void 0,
+                  sourceSubAgentId: subAgentId,
+                  targetSubAgentId: isTargetExternal ? void 0 : targetSubAgentId,
+                  externalSubAgentId: isTargetExternal ? targetSubAgentId : void 0,
                   relationType: "delegate"
                 });
                 logger13.info(
-                  { agentId, targetAgentId, type: "delegate" },
+                  { subAgentId, targetSubAgentId, type: "delegate" },
                   "Agent delegation relation processed successfully"
                 );
               } catch (error) {
                 logger13.error(
-                  { agentId, targetAgentId, type: "delegate", error },
+                  { subAgentId, targetSubAgentId, type: "delegate", error },
                   "Failed to create delegation relation"
                 );
               }
@@ -6861,7 +7101,7 @@ var updateFullGraphServerSide = (db, logger13 = defaultLogger) => async (scopes,
     {
       tenantId,
       graphId: typedGraphDefinition.id,
-      agentCount: Object.keys(typedGraphDefinition.agents).length
+      agentCount: Object.keys(typedGraphDefinition.subAgents).length
     },
     "Updating full graph in database"
   );
@@ -6899,7 +7139,7 @@ var updateFullGraphServerSide = (db, logger13 = defaultLogger) => async (scopes,
           tenantId,
           projectId,
           name: typedGraphDefinition.name,
-          defaultAgentId: typedGraphDefinition.defaultAgentId,
+          defaultSubAgentId: typedGraphDefinition.defaultSubAgentId,
           description: typedGraphDefinition.description,
           contextConfigId: void 0,
           // Will be updated later if context config exists
@@ -6957,7 +7197,7 @@ var updateFullGraphServerSide = (db, logger13 = defaultLogger) => async (scopes,
             tenantId,
             projectId,
             name: typedGraphDefinition.name,
-            defaultAgentId: typedGraphDefinition.defaultAgentId,
+            defaultSubAgentId: typedGraphDefinition.defaultSubAgentId,
             description: typedGraphDefinition.description,
             contextConfigId,
             models: typedGraphDefinition.models,
@@ -6983,15 +7223,15 @@ var updateFullGraphServerSide = (db, logger13 = defaultLogger) => async (scopes,
       {},
       "ArtifactComponents are project-scoped - skipping artifactComponent update in graph"
     );
-    const internalAgentPromises = Object.entries(typedGraphDefinition.agents).filter(([_, agentData]) => isInternalAgent(agentData)).map(async ([agentId, agentData]) => {
+    const internalAgentPromises = Object.entries(typedGraphDefinition.subAgents).filter(([_, agentData]) => isInternalAgent(agentData)).map(async ([subAgentId, agentData]) => {
       const internalAgent = agentData;
       let existingAgent = null;
       try {
-        existingAgent = await db.query.agents.findFirst({
+        existingAgent = await db.query.subAgents.findFirst({
           where: drizzleOrm.and(
-            drizzleOrm.eq(agents.id, agentId),
-            drizzleOrm.eq(agents.tenantId, tenantId),
-            drizzleOrm.eq(agents.projectId, projectId)
+            drizzleOrm.eq(subAgents.id, subAgentId),
+            drizzleOrm.eq(subAgents.tenantId, tenantId),
+            drizzleOrm.eq(subAgents.projectId, projectId)
           ),
           columns: {
             models: true
@@ -7012,7 +7252,7 @@ var updateFullGraphServerSide = (db, logger13 = defaultLogger) => async (scopes,
             cascadedModels[modelType] = graphModels[modelType];
             logger13.info(
               {
-                agentId,
+                subAgentId,
                 modelType,
                 oldModel: agentModels[modelType].model,
                 newModel: graphModels[modelType].model,
@@ -7025,10 +7265,10 @@ var updateFullGraphServerSide = (db, logger13 = defaultLogger) => async (scopes,
         finalModelSettings = cascadedModels;
       }
       try {
-        logger13.info({ agentId }, "Processing internal agent");
-        await upsertAgent(db)({
+        logger13.info({ subAgentId }, "Processing internal agent");
+        await upsertSubAgent(db)({
           data: {
-            id: agentId,
+            id: subAgentId,
             tenantId,
             projectId,
             graphId: finalGraphId,
@@ -7040,24 +7280,24 @@ var updateFullGraphServerSide = (db, logger13 = defaultLogger) => async (scopes,
             stopWhen: internalAgent.stopWhen
           }
         });
-        logger13.info({ agentId }, "Internal agent processed successfully");
+        logger13.info({ subAgentId }, "Internal agent processed successfully");
       } catch (error) {
-        logger13.error({ agentId, error }, "Failed to create/update internal agent");
+        logger13.error({ subAgentId, error }, "Failed to create/update internal agent");
         throw error;
       }
     });
     await Promise.all(internalAgentPromises);
-    const internalAgentCount = Object.entries(typedGraphDefinition.agents).filter(
+    const internalAgentCount = Object.entries(typedGraphDefinition.subAgents).filter(
       ([_, agentData]) => isInternalAgent(agentData)
     ).length;
     logger13.info({ internalAgentCount }, "All internal agents created/updated successfully");
-    const externalAgentPromises = Object.entries(typedGraphDefinition.agents).filter(([_, agentData]) => isExternalAgent(agentData)).map(async ([agentId, agentData]) => {
+    const externalAgentPromises = Object.entries(typedGraphDefinition.subAgents).filter(([_, agentData]) => isExternalAgent(agentData)).map(async ([subAgentId, agentData]) => {
       const externalAgent = agentData;
       try {
-        logger13.info({ agentId }, "Processing external agent");
+        logger13.info({ subAgentId }, "Processing external agent");
         await upsertExternalAgent(db)({
           data: {
-            id: agentId,
+            id: subAgentId,
             tenantId,
             projectId,
             graphId: finalGraphId,
@@ -7068,19 +7308,19 @@ var updateFullGraphServerSide = (db, logger13 = defaultLogger) => async (scopes,
             headers: externalAgent.headers || void 0
           }
         });
-        logger13.info({ agentId }, "External agent processed successfully");
+        logger13.info({ subAgentId }, "External agent processed successfully");
       } catch (error) {
-        logger13.error({ agentId, error }, "Failed to create/update external agent");
+        logger13.error({ subAgentId, error }, "Failed to create/update external agent");
         throw error;
       }
     });
     await Promise.all(externalAgentPromises);
-    const externalAgentCount = Object.entries(typedGraphDefinition.agents).filter(
+    const externalAgentCount = Object.entries(typedGraphDefinition.subAgents).filter(
       ([_, agentData]) => isExternalAgent(agentData)
     ).length;
     logger13.info({ externalAgentCount }, "All external agents created/updated successfully");
-    const incomingAgentIds = new Set(Object.keys(typedGraphDefinition.agents));
-    const existingInternalAgents = await listAgents(db)({
+    const incomingAgentIds = new Set(Object.keys(typedGraphDefinition.subAgents));
+    const existingInternalAgents = await listSubAgents(db)({
       scopes: { tenantId, projectId, graphId: finalGraphId }
     });
     const existingExternalAgents = await listExternalAgents(db)({
@@ -7090,14 +7330,17 @@ var updateFullGraphServerSide = (db, logger13 = defaultLogger) => async (scopes,
     for (const agent of existingInternalAgents) {
       if (!incomingAgentIds.has(agent.id)) {
         try {
-          await deleteAgent(db)({
+          await deleteSubAgent(db)({
             scopes: { tenantId, projectId, graphId: finalGraphId },
-            agentId: agent.id
+            subAgentId: agent.id
           });
           deletedInternalCount++;
-          logger13.info({ agentId: agent.id }, "Deleted orphaned internal agent");
+          logger13.info({ subAgentId: agent.id }, "Deleted orphaned internal agent");
         } catch (error) {
-          logger13.error({ agentId: agent.id, error }, "Failed to delete orphaned internal agent");
+          logger13.error(
+            { subAgentId: agent.id, error },
+            "Failed to delete orphaned internal agent"
+          );
         }
       }
     }
@@ -7107,12 +7350,15 @@ var updateFullGraphServerSide = (db, logger13 = defaultLogger) => async (scopes,
         try {
           await deleteExternalAgent(db)({
             scopes: { tenantId, projectId, graphId: finalGraphId },
-            agentId: agent.id
+            subAgentId: agent.id
           });
           deletedExternalCount++;
-          logger13.info({ agentId: agent.id }, "Deleted orphaned external agent");
+          logger13.info({ subAgentId: agent.id }, "Deleted orphaned external agent");
         } catch (error) {
-          logger13.error({ agentId: agent.id, error }, "Failed to delete orphaned external agent");
+          logger13.error(
+            { subAgentId: agent.id, error },
+            "Failed to delete orphaned external agent"
+          );
         }
       }
     }
@@ -7130,7 +7376,7 @@ var updateFullGraphServerSide = (db, logger13 = defaultLogger) => async (scopes,
       scopes: { tenantId, projectId, graphId: typedGraphDefinition.id },
       data: {
         name: typedGraphDefinition.name,
-        defaultAgentId: typedGraphDefinition.defaultAgentId,
+        defaultSubAgentId: typedGraphDefinition.defaultSubAgentId,
         description: typedGraphDefinition.description,
         contextConfigId,
         models: typedGraphDefinition.models,
@@ -7141,7 +7387,7 @@ var updateFullGraphServerSide = (db, logger13 = defaultLogger) => async (scopes,
     });
     logger13.info({ graphId: typedGraphDefinition.id }, "Graph metadata updated");
     const incomingRelationshipIds = /* @__PURE__ */ new Set();
-    for (const [_agentId, agentData] of Object.entries(typedGraphDefinition.agents)) {
+    for (const [_subAgentId, agentData] of Object.entries(typedGraphDefinition.subAgents)) {
       if (isInternalAgent(agentData) && agentData.canUse && Array.isArray(agentData.canUse)) {
         for (const canUseItem of agentData.canUse) {
           if (canUseItem.agentToolRelationId) {
@@ -7150,63 +7396,63 @@ var updateFullGraphServerSide = (db, logger13 = defaultLogger) => async (scopes,
         }
       }
     }
-    for (const agentId of Object.keys(typedGraphDefinition.agents)) {
+    for (const subAgentId of Object.keys(typedGraphDefinition.subAgents)) {
       try {
         let deletedCount = 0;
         if (incomingRelationshipIds.size === 0) {
-          const result = await db.delete(agentToolRelations).where(
+          const result = await db.delete(subAgentToolRelations).where(
             drizzleOrm.and(
-              drizzleOrm.eq(agentToolRelations.tenantId, tenantId),
-              drizzleOrm.eq(agentToolRelations.projectId, projectId),
-              drizzleOrm.eq(agentToolRelations.graphId, finalGraphId),
-              drizzleOrm.eq(agentToolRelations.agentId, agentId)
+              drizzleOrm.eq(subAgentToolRelations.tenantId, tenantId),
+              drizzleOrm.eq(subAgentToolRelations.projectId, projectId),
+              drizzleOrm.eq(subAgentToolRelations.graphId, finalGraphId),
+              drizzleOrm.eq(subAgentToolRelations.subAgentId, subAgentId)
             )
           );
           deletedCount = result.rowsAffected || 0;
         } else {
-          const result = await db.delete(agentToolRelations).where(
+          const result = await db.delete(subAgentToolRelations).where(
             drizzleOrm.and(
-              drizzleOrm.eq(agentToolRelations.tenantId, tenantId),
-              drizzleOrm.eq(agentToolRelations.projectId, projectId),
-              drizzleOrm.eq(agentToolRelations.graphId, finalGraphId),
-              drizzleOrm.eq(agentToolRelations.agentId, agentId),
-              drizzleOrm.not(drizzleOrm.inArray(agentToolRelations.id, Array.from(incomingRelationshipIds)))
+              drizzleOrm.eq(subAgentToolRelations.tenantId, tenantId),
+              drizzleOrm.eq(subAgentToolRelations.projectId, projectId),
+              drizzleOrm.eq(subAgentToolRelations.graphId, finalGraphId),
+              drizzleOrm.eq(subAgentToolRelations.subAgentId, subAgentId),
+              drizzleOrm.not(drizzleOrm.inArray(subAgentToolRelations.id, Array.from(incomingRelationshipIds)))
             )
           );
           deletedCount = result.rowsAffected || 0;
         }
         if (deletedCount > 0) {
-          logger13.info({ agentId, deletedCount }, "Deleted orphaned agent-tool relations");
+          logger13.info({ subAgentId, deletedCount }, "Deleted orphaned agent-tool relations");
         }
       } catch (error) {
-        logger13.error({ agentId, error }, "Failed to delete orphaned agent-tool relations");
+        logger13.error({ subAgentId, error }, "Failed to delete orphaned agent-tool relations");
       }
     }
     const agentToolPromises = [];
-    for (const [agentId, agentData] of Object.entries(typedGraphDefinition.agents)) {
+    for (const [subAgentId, agentData] of Object.entries(typedGraphDefinition.subAgents)) {
       if (isInternalAgent(agentData) && agentData.canUse && Array.isArray(agentData.canUse)) {
         for (const canUseItem of agentData.canUse) {
           agentToolPromises.push(
             (async () => {
               try {
                 const { toolId, toolSelection, headers: headers2, agentToolRelationId } = canUseItem;
-                logger13.info({ agentId, toolId }, "Processing agent-tool relation");
+                logger13.info({ subAgentId, toolId }, "Processing agent-tool relation");
                 await upsertAgentToolRelation(db)({
                   scopes: { tenantId, projectId, graphId: finalGraphId },
-                  agentId,
+                  subAgentId,
                   toolId,
                   selectedTools: toolSelection || void 0,
                   headers: headers2 || void 0,
                   relationId: agentToolRelationId
                 });
                 logger13.info(
-                  { agentId, toolId, relationId: agentToolRelationId },
+                  { subAgentId, toolId, relationId: agentToolRelationId },
                   "Agent-tool relation upserted"
                 );
               } catch (error) {
                 logger13.error(
                   {
-                    agentId,
+                    subAgentId,
                     toolId: canUseItem.toolId,
                     relationId: canUseItem.agentToolRelationId,
                     error
@@ -7224,26 +7470,29 @@ var updateFullGraphServerSide = (db, logger13 = defaultLogger) => async (scopes,
       { agentToolPromisesCount: agentToolPromises.length },
       "All agent-tool relations updated"
     );
-    for (const agentId of Object.keys(typedGraphDefinition.agents)) {
+    for (const subAgentId of Object.keys(typedGraphDefinition.subAgents)) {
       await deleteAgentDataComponentRelationByAgent(db)({
-        scopes: { tenantId, projectId, graphId: finalGraphId, agentId }
+        scopes: { tenantId, projectId, graphId: finalGraphId, subAgentId }
       });
     }
     const agentDataComponentPromises = [];
-    for (const [agentId, agentData] of Object.entries(typedGraphDefinition.agents)) {
+    for (const [subAgentId, agentData] of Object.entries(typedGraphDefinition.subAgents)) {
       if (isInternalAgent(agentData) && agentData.dataComponents) {
         for (const dataComponentId of agentData.dataComponents) {
           agentDataComponentPromises.push(
             (async () => {
               try {
                 await associateDataComponentWithAgent(db)({
-                  scopes: { tenantId, projectId, graphId: finalGraphId, agentId },
+                  scopes: { tenantId, projectId, graphId: finalGraphId, subAgentId },
                   dataComponentId
                 });
-                logger13.info({ agentId, dataComponentId }, "Agent-dataComponent relation created");
+                logger13.info(
+                  { subAgentId, dataComponentId },
+                  "Agent-dataComponent relation created"
+                );
               } catch (error) {
                 logger13.error(
-                  { agentId, dataComponentId, error },
+                  { subAgentId, dataComponentId, error },
                   "Failed to create agent-dataComponent relation"
                 );
               }
@@ -7257,29 +7506,29 @@ var updateFullGraphServerSide = (db, logger13 = defaultLogger) => async (scopes,
       { agentDataComponentPromisesCount: agentDataComponentPromises.length },
       "All agent-dataComponent relations updated"
     );
-    for (const agentId of Object.keys(typedGraphDefinition.agents)) {
+    for (const subAgentId of Object.keys(typedGraphDefinition.subAgents)) {
       await deleteAgentArtifactComponentRelationByAgent(db)({
-        scopes: { tenantId, projectId, graphId: finalGraphId, agentId }
+        scopes: { tenantId, projectId, graphId: finalGraphId, subAgentId }
       });
     }
     const agentArtifactComponentPromises = [];
-    for (const [agentId, agentData] of Object.entries(typedGraphDefinition.agents)) {
+    for (const [subAgentId, agentData] of Object.entries(typedGraphDefinition.subAgents)) {
       if (isInternalAgent(agentData) && agentData.artifactComponents) {
         for (const artifactComponentId of agentData.artifactComponents) {
           agentArtifactComponentPromises.push(
             (async () => {
               try {
                 await associateArtifactComponentWithAgent(db)({
-                  scopes: { tenantId, projectId, graphId: finalGraphId, agentId },
+                  scopes: { tenantId, projectId, graphId: finalGraphId, subAgentId },
                   artifactComponentId
                 });
                 logger13.info(
-                  { agentId, artifactComponentId },
+                  { subAgentId, artifactComponentId },
                   "Agent-artifactComponent relation created"
                 );
               } catch (error) {
                 logger13.error(
-                  { agentId, artifactComponentId, error },
+                  { subAgentId, artifactComponentId, error },
                   "Failed to create agent-artifactComponent relation"
                 );
               }
@@ -7297,34 +7546,34 @@ var updateFullGraphServerSide = (db, logger13 = defaultLogger) => async (scopes,
       scopes: { tenantId, projectId, graphId: typedGraphDefinition.id }
     });
     const agentRelationPromises = [];
-    for (const [agentId, agentData] of Object.entries(typedGraphDefinition.agents)) {
+    for (const [subAgentId, agentData] of Object.entries(typedGraphDefinition.subAgents)) {
       if (isInternalAgent(agentData) && agentData.canTransferTo) {
-        for (const targetAgentId of agentData.canTransferTo) {
+        for (const targetSubAgentId of agentData.canTransferTo) {
           agentRelationPromises.push(
             (async () => {
               try {
-                const targetAgentData = typedGraphDefinition.agents[targetAgentId];
+                const targetAgentData = typedGraphDefinition.subAgents[targetSubAgentId];
                 const isTargetExternal = isExternalAgent(targetAgentData);
-                const targetField = isTargetExternal ? "externalAgentId" : "targetAgentId";
+                const targetField = isTargetExternal ? "externalSubAgentId" : "targetSubAgentId";
                 const relationData = {
                   id: nanoid.nanoid(),
                   graphId: typedGraphDefinition.id || "",
-                  sourceAgentId: agentId,
+                  sourceSubAgentId: subAgentId,
                   relationType: "transfer",
-                  [targetField]: targetAgentId
+                  [targetField]: targetSubAgentId
                 };
-                await createAgentRelation(db)({
+                await createSubAgentRelation(db)({
                   tenantId,
                   projectId,
                   ...relationData
                 });
                 logger13.info(
-                  { agentId, targetAgentId, isTargetExternal },
+                  { subAgentId, targetSubAgentId, isTargetExternal },
                   "Transfer relation created"
                 );
               } catch (error) {
                 logger13.error(
-                  { agentId, targetAgentId, error },
+                  { subAgentId, targetSubAgentId, error },
                   "Failed to create transfer relation"
                 );
               }
@@ -7333,29 +7582,29 @@ var updateFullGraphServerSide = (db, logger13 = defaultLogger) => async (scopes,
         }
       }
       if (isInternalAgent(agentData) && agentData.canDelegateTo) {
-        for (const targetAgentId of agentData.canDelegateTo) {
-          const targetAgentData = typedGraphDefinition.agents[targetAgentId];
+        for (const targetSubAgentId of agentData.canDelegateTo) {
+          const targetAgentData = typedGraphDefinition.subAgents[targetSubAgentId];
           const isTargetExternal = isExternalAgent(targetAgentData);
-          const targetField = isTargetExternal ? "externalAgentId" : "targetAgentId";
+          const targetField = isTargetExternal ? "externalSubAgentId" : "targetSubAgentId";
           agentRelationPromises.push(
             (async () => {
               try {
                 const relationData = {
                   id: nanoid.nanoid(),
                   graphId: typedGraphDefinition.id || "",
-                  sourceAgentId: agentId,
+                  sourceSubAgentId: subAgentId,
                   relationType: "delegate",
-                  [targetField]: targetAgentId
+                  [targetField]: targetSubAgentId
                 };
-                await createAgentRelation(db)({
+                await createSubAgentRelation(db)({
                   tenantId,
                   projectId,
                   ...relationData
                 });
-                logger13.info({ agentId, targetAgentId }, "Delegation relation created");
+                logger13.info({ subAgentId, targetSubAgentId }, "Delegation relation created");
               } catch (error) {
                 logger13.error(
-                  { agentId, targetAgentId, error },
+                  { subAgentId, targetSubAgentId, error },
                   "Failed to create delegation relation"
                 );
               }
@@ -7398,7 +7647,7 @@ var getFullGraph = (db, logger13 = defaultLogger) => async (params) => {
       {
         tenantId,
         graphId: scopes.graphId,
-        agentCount: Object.keys(graph.agents).length
+        agentCount: Object.keys(graph.subAgents).length
       },
       "Full graph retrieved successfully"
     );
@@ -7430,15 +7679,15 @@ var deleteFullGraph = (db, logger13 = defaultLogger) => async (params) => {
       scopes: { tenantId, projectId, graphId }
     });
     logger13.info({ tenantId, graphId }, "Agent relations deleted");
-    const agentIds = Object.keys(graph.agents);
-    if (agentIds.length > 0) {
-      for (const agentId of agentIds) {
+    const subAgentIds = Object.keys(graph.subAgents);
+    if (subAgentIds.length > 0) {
+      for (const subAgentId of subAgentIds) {
         await deleteAgentToolRelationByAgent(db)({
-          scopes: { tenantId, projectId, graphId, agentId }
+          scopes: { tenantId, projectId, graphId, subAgentId }
         });
       }
       logger13.info(
-        { tenantId, graphId, agentCount: agentIds.length },
+        { tenantId, graphId, agentCount: subAgentIds.length },
         "Agent-tool relations deleted"
       );
     }
@@ -7837,15 +8086,15 @@ var listProjects = (db) => async (params) => {
     return projectsFromTable.map((p) => ({ projectId: p.projectId }));
   }
   const projectIdSets = await Promise.all([
-    db.selectDistinct({ projectId: agents.projectId }).from(agents).where(drizzleOrm.eq(agents.tenantId, params.tenantId)),
+    db.selectDistinct({ projectId: subAgents.projectId }).from(subAgents).where(drizzleOrm.eq(subAgents.tenantId, params.tenantId)),
     db.selectDistinct({ projectId: agentGraph.projectId }).from(agentGraph).where(drizzleOrm.eq(agentGraph.tenantId, params.tenantId)),
     db.selectDistinct({ projectId: tools.projectId }).from(tools).where(drizzleOrm.eq(tools.tenantId, params.tenantId)),
     db.selectDistinct({ projectId: contextConfigs.projectId }).from(contextConfigs).where(drizzleOrm.eq(contextConfigs.tenantId, params.tenantId)),
     db.selectDistinct({ projectId: externalAgents.projectId }).from(externalAgents).where(drizzleOrm.eq(externalAgents.tenantId, params.tenantId)),
-    db.selectDistinct({ projectId: agentRelations.projectId }).from(agentRelations).where(drizzleOrm.eq(agentRelations.tenantId, params.tenantId)),
-    db.selectDistinct({ projectId: agentToolRelations.projectId }).from(agentToolRelations).where(drizzleOrm.eq(agentToolRelations.tenantId, params.tenantId)),
-    db.selectDistinct({ projectId: agentDataComponents.projectId }).from(agentDataComponents).where(drizzleOrm.eq(agentDataComponents.tenantId, params.tenantId)),
-    db.selectDistinct({ projectId: agentArtifactComponents.projectId }).from(agentArtifactComponents).where(drizzleOrm.eq(agentArtifactComponents.tenantId, params.tenantId)),
+    db.selectDistinct({ projectId: subAgentRelations.projectId }).from(subAgentRelations).where(drizzleOrm.eq(subAgentRelations.tenantId, params.tenantId)),
+    db.selectDistinct({ projectId: subAgentToolRelations.projectId }).from(subAgentToolRelations).where(drizzleOrm.eq(subAgentToolRelations.tenantId, params.tenantId)),
+    db.selectDistinct({ projectId: subAgentDataComponents.projectId }).from(subAgentDataComponents).where(drizzleOrm.eq(subAgentDataComponents.tenantId, params.tenantId)),
+    db.selectDistinct({ projectId: subAgentArtifactComponents.projectId }).from(subAgentArtifactComponents).where(drizzleOrm.eq(subAgentArtifactComponents.tenantId, params.tenantId)),
     db.selectDistinct({ projectId: dataComponents.projectId }).from(dataComponents).where(drizzleOrm.eq(dataComponents.tenantId, params.tenantId)),
     db.selectDistinct({ projectId: artifactComponents.projectId }).from(artifactComponents).where(drizzleOrm.eq(artifactComponents.tenantId, params.tenantId)),
     db.selectDistinct({ projectId: tasks.projectId }).from(tasks).where(drizzleOrm.eq(tasks.tenantId, params.tenantId)),
@@ -7885,7 +8134,7 @@ var listProjectsPaginated = (db) => async (params) => {
 var getProjectResourceCounts = (db) => async (params) => {
   const whereClause = (table) => drizzleOrm.and(drizzleOrm.eq(table.tenantId, params.tenantId), drizzleOrm.eq(table.projectId, params.projectId));
   const [agentResults, graphResults, toolResults, contextConfigResults, externalAgentResults] = await Promise.all([
-    db.select({ count: agents.id }).from(agents).where(whereClause(agents)),
+    db.select({ count: subAgents.id }).from(subAgents).where(whereClause(subAgents)),
     db.select({ count: agentGraph.id }).from(agentGraph).where(whereClause(agentGraph)),
     db.select({ count: tools.id }).from(tools).where(whereClause(tools)),
     db.select({ count: contextConfigs.id }).from(contextConfigs).where(whereClause(contextConfigs)),
@@ -7902,7 +8151,7 @@ var getProjectResourceCounts = (db) => async (params) => {
 var projectExists = (db) => async (params) => {
   const whereClause = (table) => drizzleOrm.and(drizzleOrm.eq(table.tenantId, params.tenantId), drizzleOrm.eq(table.projectId, params.projectId));
   const checks = [
-    db.select({ id: agents.id }).from(agents).where(whereClause(agents)).limit(1),
+    db.select({ id: subAgents.id }).from(subAgents).where(whereClause(subAgents)).limit(1),
     db.select({ id: agentGraph.id }).from(agentGraph).where(whereClause(agentGraph)).limit(1),
     db.select({ id: tools.id }).from(tools).where(whereClause(tools)).limit(1),
     db.select({ id: contextConfigs.id }).from(contextConfigs).where(whereClause(contextConfigs)).limit(1),
@@ -8009,8 +8258,8 @@ async function cascadeStopWhenUpdates(db, scopes, oldStopWhen, newStopWhen) {
     }
   }
   if (oldStopWhen?.stepCountIs !== newStopWhen?.stepCountIs) {
-    const agentsToUpdate = await db.query.agents.findMany({
-      where: drizzleOrm.and(drizzleOrm.eq(agents.tenantId, tenantId), drizzleOrm.eq(agents.projectId, projectId))
+    const agentsToUpdate = await db.query.subAgents.findMany({
+      where: drizzleOrm.and(drizzleOrm.eq(subAgents.tenantId, tenantId), drizzleOrm.eq(subAgents.projectId, projectId))
     });
     for (const agent of agentsToUpdate) {
       const agentStopWhen = agent.stopWhen;
@@ -8019,14 +8268,14 @@ async function cascadeStopWhenUpdates(db, scopes, oldStopWhen, newStopWhen) {
           ...agentStopWhen || {},
           stepCountIs: newStopWhen?.stepCountIs
         };
-        await db.update(agents).set({
+        await db.update(subAgents).set({
           stopWhen: updatedStopWhen,
           updatedAt: (/* @__PURE__ */ new Date()).toISOString()
         }).where(
           drizzleOrm.and(
-            drizzleOrm.eq(agents.tenantId, tenantId),
-            drizzleOrm.eq(agents.projectId, projectId),
-            drizzleOrm.eq(agents.id, agent.id)
+            drizzleOrm.eq(subAgents.tenantId, tenantId),
+            drizzleOrm.eq(subAgents.projectId, projectId),
+            drizzleOrm.eq(subAgents.id, agent.id)
           )
         );
       }
@@ -8278,6 +8527,10 @@ var createFullProjectServerSide = (db, logger13 = defaultLogger2) => async (scop
           logger13.info({ projectId: typed.id, graphId }, "Creating graph in project");
           const graphDataWithProjectResources = {
             ...graphData,
+            agents: void 0,
+            // Remove 'agents' property from GraphWithinContextOfProjectSchema
+            subAgents: graphData.subAgents,
+            // Map 'agents' to 'subAgents' for FullGraphDefinitionSchema
             tools: typed.tools || {},
             // Pass project-level resources for validation
             dataComponents: typed.dataComponents || {},
@@ -8617,6 +8870,10 @@ var updateFullProjectServerSide = (db, logger13 = defaultLogger2) => async (scop
           logger13.info({ projectId: typed.id, graphId }, "Updating graph in project");
           const graphDataWithProjectResources = {
             ...graphData,
+            agents: void 0,
+            // Remove 'agents' property from GraphWithinContextOfProjectSchema
+            subAgents: graphData.subAgents,
+            // Map 'agents' to 'subAgents' for FullGraphDefinitionSchema
             tools: typed.tools || {},
             // Pass project-level resources for validation
             dataComponents: typed.dataComponents || {},
@@ -9720,7 +9977,7 @@ async function validateHeaders({
   credentialStores
 }) {
   try {
-    const agentGraph2 = await getAgentGraphWithDefaultAgent(dbClient)({
+    const agentGraph2 = await getAgentGraphWithDefaultSubAgent(dbClient)({
       scopes: { tenantId, projectId, graphId }
     });
     if (!agentGraph2?.contextConfigId) {
@@ -10283,7 +10540,7 @@ async function handleContextResolution({
       let agentGraph2;
       let trigger;
       try {
-        agentGraph2 = await getAgentGraphWithDefaultAgent(dbClient)({
+        agentGraph2 = await getAgentGraphWithDefaultSubAgent(dbClient)({
           scopes: { tenantId, projectId, graphId }
         });
         if (!agentGraph2?.contextConfigId) {
@@ -11211,6 +11468,43 @@ ${error.message}`
   }
 };
 parseEnv();
+var TransferDataSchema = zod.z.object({
+  fromSubAgent: zod.z.string().describe("ID of the sub-agent transferring control"),
+  targetSubAgent: zod.z.string().describe("ID of the sub-agent receiving control"),
+  reason: zod.z.string().optional().describe("Reason for the transfer"),
+  context: zod.z.any().optional().describe("Additional context data")
+});
+var DelegationSentDataSchema = zod.z.object({
+  delegationId: zod.z.string().describe("Unique identifier for this delegation"),
+  fromSubAgent: zod.z.string().describe("ID of the delegating sub-agent"),
+  targetSubAgent: zod.z.string().describe("ID of the sub-agent receiving the delegation"),
+  taskDescription: zod.z.string().describe("Description of the delegated task"),
+  context: zod.z.any().optional().describe("Additional context data")
+});
+var DelegationReturnedDataSchema = zod.z.object({
+  delegationId: zod.z.string().describe("Unique identifier matching the original delegation"),
+  fromSubAgent: zod.z.string().describe("ID of the sub-agent that completed the task"),
+  targetSubAgent: zod.z.string().describe("ID of the sub-agent receiving the result"),
+  result: zod.z.any().optional().describe("Result data from the delegated task")
+});
+var DataOperationDetailsSchema = zod.z.object({
+  timestamp: zod.z.number().describe("Unix timestamp in milliseconds"),
+  subAgentId: zod.z.string().describe("ID of the sub-agent that generated this data"),
+  data: zod.z.any().describe("The actual data payload")
+});
+var DataOperationEventSchema = zod.z.object({
+  type: zod.z.string().describe("Event type identifier"),
+  label: zod.z.string().describe("Human-readable label for the event"),
+  details: DataOperationDetailsSchema
+});
+var A2AMessageMetadataSchema = zod.z.object({
+  fromSubAgentId: zod.z.string().optional().describe("ID of the sending sub-agent"),
+  toSubAgentId: zod.z.string().optional().describe("ID of the receiving sub-agent"),
+  fromExternalAgentId: zod.z.string().optional().describe("ID of the sending external agent"),
+  toExternalAgentId: zod.z.string().optional().describe("ID of the receiving external agent"),
+  taskId: zod.z.string().optional().describe("Associated task ID"),
+  a2aTaskId: zod.z.string().optional().describe("A2A-specific task ID")
+});
 
 // src/validation/id-validation.ts
 function isValidResourceId(id) {
@@ -11230,9 +11524,14 @@ function generateIdFromName(name) {
   return truncatedId;
 }
 
-exports.AgentApiInsertSchema = AgentApiInsertSchema;
-exports.AgentApiSelectSchema = AgentApiSelectSchema;
-exports.AgentApiUpdateSchema = AgentApiUpdateSchema;
+exports.A2AMessageMetadataSchema = A2AMessageMetadataSchema;
+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.AgentArtifactComponentApiInsertSchema = AgentArtifactComponentApiInsertSchema;
 exports.AgentArtifactComponentApiSelectSchema = AgentArtifactComponentApiSelectSchema;
 exports.AgentArtifactComponentApiUpdateSchema = AgentArtifactComponentApiUpdateSchema;
@@ -11251,7 +11550,6 @@ exports.AgentGraphApiUpdateSchema = AgentGraphApiUpdateSchema;
 exports.AgentGraphInsertSchema = AgentGraphInsertSchema;
 exports.AgentGraphSelectSchema = AgentGraphSelectSchema;
 exports.AgentGraphUpdateSchema = AgentGraphUpdateSchema;
-exports.AgentInsertSchema = AgentInsertSchema;
 exports.AgentRelationApiInsertSchema = AgentRelationApiInsertSchema;
 exports.AgentRelationApiSelectSchema = AgentRelationApiSelectSchema;
 exports.AgentRelationApiUpdateSchema = AgentRelationApiUpdateSchema;
@@ -11259,7 +11557,6 @@ exports.AgentRelationInsertSchema = AgentRelationInsertSchema;
 exports.AgentRelationQuerySchema = AgentRelationQuerySchema;
 exports.AgentRelationSelectSchema = AgentRelationSelectSchema;
 exports.AgentRelationUpdateSchema = AgentRelationUpdateSchema;
-exports.AgentSelectSchema = AgentSelectSchema;
 exports.AgentStopWhenSchema = AgentStopWhenSchema;
 exports.AgentToolRelationApiInsertSchema = AgentToolRelationApiInsertSchema;
 exports.AgentToolRelationApiSelectSchema = AgentToolRelationApiSelectSchema;
@@ -11267,7 +11564,6 @@ exports.AgentToolRelationApiUpdateSchema = AgentToolRelationApiUpdateSchema;
 exports.AgentToolRelationInsertSchema = AgentToolRelationInsertSchema;
 exports.AgentToolRelationSelectSchema = AgentToolRelationSelectSchema;
 exports.AgentToolRelationUpdateSchema = AgentToolRelationUpdateSchema;
-exports.AgentUpdateSchema = AgentUpdateSchema;
 exports.AllAgentSchema = AllAgentSchema;
 exports.ApiKeyApiCreationResponseSchema = ApiKeyApiCreationResponseSchema;
 exports.ApiKeyApiInsertSchema = ApiKeyApiInsertSchema;
@@ -11314,6 +11610,11 @@ exports.CredentialReferenceUpdateSchema = CredentialReferenceUpdateSchema;
 exports.CredentialStoreRegistry = CredentialStoreRegistry;
 exports.CredentialStoreType = CredentialStoreType;
 exports.CredentialStuffer = CredentialStuffer;
+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 = DataComponentApiInsertSchema;
 exports.DataComponentApiSelectSchema = DataComponentApiSelectSchema;
 exports.DataComponentApiUpdateSchema = DataComponentApiUpdateSchema;
@@ -11321,6 +11622,10 @@ exports.DataComponentBaseSchema = DataComponentBaseSchema;
 exports.DataComponentInsertSchema = DataComponentInsertSchema;
 exports.DataComponentSelectSchema = DataComponentSelectSchema;
 exports.DataComponentUpdateSchema = DataComponentUpdateSchema;
+exports.DataOperationDetailsSchema = DataOperationDetailsSchema;
+exports.DataOperationEventSchema = DataOperationEventSchema;
+exports.DelegationReturnedDataSchema = DelegationReturnedDataSchema;
+exports.DelegationSentDataSchema = DelegationSentDataSchema;
 exports.ERROR_DOCS_BASE_URL = ERROR_DOCS_BASE_URL;
 exports.ErrorCode = ErrorCode;
 exports.ErrorResponseSchema = ErrorResponseSchema;
@@ -11333,10 +11638,10 @@ exports.ExternalAgentRelationApiInsertSchema = ExternalAgentRelationApiInsertSch
 exports.ExternalAgentRelationInsertSchema = ExternalAgentRelationInsertSchema;
 exports.ExternalAgentSelectSchema = ExternalAgentSelectSchema;
 exports.ExternalAgentUpdateSchema = ExternalAgentUpdateSchema;
+exports.FIELD_TYPES = FIELD_TYPES;
 exports.FetchConfigSchema = FetchConfigSchema;
 exports.FetchDefinitionSchema = FetchDefinitionSchema;
 exports.FullGraphAgentInsertSchema = FullGraphAgentInsertSchema;
-exports.FullGraphDefinitionSchema = FullGraphDefinitionSchema;
 exports.FullProjectDefinitionSchema = FullProjectDefinitionSchema;
 exports.FunctionApiInsertSchema = FunctionApiInsertSchema;
 exports.FunctionApiSelectSchema = FunctionApiSelectSchema;
@@ -11349,7 +11654,6 @@ exports.GraphStopWhenSchema = GraphStopWhenSchema;
 exports.GraphWithinContextOfProjectSchema = GraphWithinContextOfProjectSchema;
 exports.HTTP_REQUEST_PARTS = HTTP_REQUEST_PARTS;
 exports.HeadersScopeSchema = HeadersScopeSchema;
-exports.IdParamsSchema = IdParamsSchema;
 exports.InMemoryCredentialStore = InMemoryCredentialStore;
 exports.KeyChainStore = KeyChainStore;
 exports.LedgerArtifactApiInsertSchema = LedgerArtifactApiInsertSchema;
@@ -11377,6 +11681,9 @@ exports.MessageUpdateSchema = MessageUpdateSchema;
 exports.ModelSchema = ModelSchema;
 exports.ModelSettingsSchema = ModelSettingsSchema;
 exports.NangoCredentialStore = NangoCredentialStore;
+exports.OPERATORS = OPERATORS;
+exports.ORDER_DIRECTIONS = ORDER_DIRECTIONS;
+exports.PANEL_TYPES = PANEL_TYPES;
 exports.PaginationQueryParamsSchema = PaginationQueryParamsSchema;
 exports.PaginationSchema = PaginationSchema;
 exports.PinoLogger = PinoLogger;
@@ -11387,13 +11694,29 @@ exports.ProjectInsertSchema = ProjectInsertSchema;
 exports.ProjectModelSchema = ProjectModelSchema;
 exports.ProjectSelectSchema = ProjectSelectSchema;
 exports.ProjectUpdateSchema = ProjectUpdateSchema;
+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.RemovedResponseSchema = RemovedResponseSchema;
+exports.SPAN_KEYS = SPAN_KEYS;
+exports.SPAN_NAMES = SPAN_NAMES;
 exports.SandboxConfigSchema = SandboxConfigSchema;
 exports.SingleResponseSchema = SingleResponseSchema;
 exports.StatusComponentSchema = StatusComponentSchema;
 exports.StatusUpdateSchema = StatusUpdateSchema;
 exports.StopWhenSchema = StopWhenSchema;
+exports.SubAgentApiInsertSchema = SubAgentApiInsertSchema;
+exports.SubAgentApiSelectSchema = SubAgentApiSelectSchema;
+exports.SubAgentApiUpdateSchema = SubAgentApiUpdateSchema;
+exports.SubAgentInsertSchema = SubAgentInsertSchema;
+exports.SubAgentSelectSchema = SubAgentSelectSchema;
+exports.SubAgentUpdateSchema = SubAgentUpdateSchema;
+exports.TOOL_NAMES = TOOL_NAMES;
 exports.TOOL_STATUS_VALUES = TOOL_STATUS_VALUES;
+exports.TRANSFER_FROM_SUB_AGENT_ID = TRANSFER_FROM_SUB_AGENT_ID;
+exports.TRANSFER_TO_SUB_AGENT_ID = TRANSFER_TO_SUB_AGENT_ID;
 exports.TaskApiInsertSchema = TaskApiInsertSchema;
 exports.TaskApiSelectSchema = TaskApiSelectSchema;
 exports.TaskApiUpdateSchema = TaskApiUpdateSchema;
@@ -11412,6 +11735,8 @@ exports.TenantIdParamsSchema = TenantIdParamsSchema;
 exports.TenantParamsSchema = TenantParamsSchema;
 exports.TenantProjectGraphIdParamsSchema = TenantProjectGraphIdParamsSchema;
 exports.TenantProjectGraphParamsSchema = TenantProjectGraphParamsSchema;
+exports.TenantProjectGraphSubAgentIdParamsSchema = TenantProjectGraphSubAgentIdParamsSchema;
+exports.TenantProjectGraphSubAgentParamsSchema = TenantProjectGraphSubAgentParamsSchema;
 exports.TenantProjectIdParamsSchema = TenantProjectIdParamsSchema;
 exports.TenantProjectParamsSchema = TenantProjectParamsSchema;
 exports.ToolApiInsertSchema = ToolApiInsertSchema;
@@ -11421,22 +11746,15 @@ exports.ToolInsertSchema = ToolInsertSchema;
 exports.ToolSelectSchema = ToolSelectSchema;
 exports.ToolStatusSchema = ToolStatusSchema;
 exports.ToolUpdateSchema = ToolUpdateSchema;
+exports.TransferDataSchema = TransferDataSchema;
+exports.UNKNOWN_VALUE = UNKNOWN_VALUE;
 exports.URL_SAFE_ID_PATTERN = URL_SAFE_ID_PATTERN;
 exports.VALID_RELATION_TYPES = VALID_RELATION_TYPES;
 exports.addLedgerArtifacts = addLedgerArtifacts;
 exports.addToolToAgent = addToolToAgent;
-exports.agentArtifactComponents = agentArtifactComponents;
-exports.agentArtifactComponentsRelations = agentArtifactComponentsRelations;
-exports.agentDataComponents = agentDataComponents;
-exports.agentDataComponentsRelations = agentDataComponentsRelations;
 exports.agentGraph = agentGraph;
 exports.agentGraphRelations = agentGraphRelations;
-exports.agentRelations = agentRelations;
-exports.agentRelationsRelations = agentRelationsRelations;
-exports.agentToolRelations = agentToolRelations;
 exports.agentToolRelationsRelations = agentToolRelationsRelations;
-exports.agents = agents;
-exports.agentsRelations = agentsRelations;
 exports.apiFetch = apiFetch;
 exports.apiKeys = apiKeys;
 exports.apiKeysRelations = apiKeysRelations;
@@ -11471,9 +11789,7 @@ exports.countExternalAgents = countExternalAgents;
 exports.countLedgerArtifactsByTask = countLedgerArtifactsByTask;
 exports.countMessagesByConversation = countMessagesByConversation;
 exports.countProjects = countProjects;
-exports.createAgent = createAgent;
 exports.createAgentGraph = createAgentGraph;
-exports.createAgentRelation = createAgentRelation;
 exports.createAgentToolRelation = createAgentToolRelation;
 exports.createApiError = createApiError;
 exports.createApiKey = createApiKey;
@@ -11495,6 +11811,8 @@ exports.createMessage = createMessage;
 exports.createNangoCredentialStore = createNangoCredentialStore;
 exports.createOrGetConversation = createOrGetConversation;
 exports.createProject = createProject;
+exports.createSubAgent = createSubAgent;
+exports.createSubAgentRelation = createSubAgentRelation;
 exports.createTask = createTask;
 exports.createTool = createTool;
 exports.createValidatedDataAccess = createValidatedDataAccess;
@@ -11503,11 +11821,9 @@ exports.credentialReferencesRelations = credentialReferencesRelations;
 exports.dataComponents = dataComponents;
 exports.dataComponentsRelations = dataComponentsRelations;
 exports.dbResultToMcpTool = dbResultToMcpTool;
-exports.deleteAgent = deleteAgent;
 exports.deleteAgentArtifactComponentRelationByAgent = deleteAgentArtifactComponentRelationByAgent;
 exports.deleteAgentDataComponentRelationByAgent = deleteAgentDataComponentRelationByAgent;
 exports.deleteAgentGraph = deleteAgentGraph;
-exports.deleteAgentRelation = deleteAgentRelation;
 exports.deleteAgentRelationsByGraph = deleteAgentRelationsByGraph;
 exports.deleteAgentToolRelation = deleteAgentToolRelation;
 exports.deleteAgentToolRelationByAgent = deleteAgentToolRelationByAgent;
@@ -11525,6 +11841,8 @@ exports.deleteLedgerArtifactsByContext = deleteLedgerArtifactsByContext;
 exports.deleteLedgerArtifactsByTask = deleteLedgerArtifactsByTask;
 exports.deleteMessage = deleteMessage;
 exports.deleteProject = deleteProject;
+exports.deleteSubAgent = deleteSubAgent;
+exports.deleteSubAgentRelation = deleteSubAgentRelation;
 exports.deleteTool = deleteTool;
 exports.detectAuthenticationRequired = detectAuthenticationRequired;
 exports.determineContextTrigger = determineContextTrigger;
@@ -11546,9 +11864,8 @@ exports.generateApiKey = generateApiKey;
 exports.generateId = generateId;
 exports.generateIdFromName = generateIdFromName;
 exports.getActiveAgentForConversation = getActiveAgentForConversation;
-exports.getAgentById = getAgentById;
 exports.getAgentGraphById = getAgentGraphById;
-exports.getAgentGraphWithDefaultAgent = getAgentGraphWithDefaultAgent;
+exports.getAgentGraphWithDefaultSubAgent = getAgentGraphWithDefaultSubAgent;
 exports.getAgentRelationById = getAgentRelationById;
 exports.getAgentRelationByParams = getAgentRelationByParams;
 exports.getAgentRelations = getAgentRelations;
@@ -11558,7 +11875,6 @@ exports.getAgentRelationsByTarget = getAgentRelationsByTarget;
 exports.getAgentToolRelationByAgent = getAgentToolRelationByAgent;
 exports.getAgentToolRelationById = getAgentToolRelationById;
 exports.getAgentToolRelationByTool = getAgentToolRelationByTool;
-exports.getAgentsByIds = getAgentsByIds;
 exports.getAgentsForTool = getAgentsForTool;
 exports.getAgentsUsingArtifactComponent = getAgentsUsingArtifactComponent;
 exports.getAgentsUsingDataComponent = getAgentsUsingDataComponent;
@@ -11598,6 +11914,8 @@ exports.getProject = getProject;
 exports.getProjectResourceCounts = getProjectResourceCounts;
 exports.getRelatedAgentsForGraph = getRelatedAgentsForGraph;
 exports.getRequestExecutionContext = getRequestExecutionContext;
+exports.getSubAgentById = getSubAgentById;
+exports.getSubAgentsByIds = getSubAgentsByIds;
 exports.getTask = getTask;
 exports.getToolById = getToolById;
 exports.getToolsForAgent = getToolsForAgent;
@@ -11628,8 +11946,6 @@ exports.listAgentGraphs = listAgentGraphs;
 exports.listAgentGraphsPaginated = listAgentGraphsPaginated;
 exports.listAgentRelations = listAgentRelations;
 exports.listAgentToolRelations = listAgentToolRelations;
-exports.listAgents = listAgents;
-exports.listAgentsPaginated = listAgentsPaginated;
 exports.listApiKeys = listApiKeys;
 exports.listApiKeysPaginated = listApiKeysPaginated;
 exports.listArtifactComponents = listArtifactComponents;
@@ -11647,6 +11963,8 @@ exports.listFunctions = listFunctions;
 exports.listMessages = listMessages;
 exports.listProjects = listProjects;
 exports.listProjectsPaginated = listProjectsPaginated;
+exports.listSubAgents = listSubAgents;
+exports.listSubAgentsPaginated = listSubAgentsPaginated;
 exports.listTaskIdsByContextId = listTaskIdsByContextId;
 exports.listTools = listTools;
 exports.loadEnvironmentFiles = loadEnvironmentFiles;
@@ -11669,13 +11987,21 @@ exports.setActiveAgentForConversation = setActiveAgentForConversation;
 exports.setActiveAgentForThread = setActiveAgentForThread;
 exports.setCacheEntry = setCacheEntry;
 exports.setSpanWithError = setSpanWithError;
+exports.subAgentArtifactComponents = subAgentArtifactComponents;
+exports.subAgentArtifactComponentsRelations = subAgentArtifactComponentsRelations;
+exports.subAgentDataComponents = subAgentDataComponents;
+exports.subAgentDataComponentsRelations = subAgentDataComponentsRelations;
+exports.subAgentRelations = subAgentRelations;
+exports.subAgentRelationsRelations = subAgentRelationsRelations;
+exports.subAgentToolRelations = subAgentToolRelations;
+exports.subAgents = subAgents;
+exports.subAgentsRelations = subAgentsRelations;
 exports.taskRelations = taskRelations;
 exports.taskRelationsRelations = taskRelationsRelations;
 exports.tasks = tasks;
 exports.tasksRelations = tasksRelations;
 exports.tools = tools;
 exports.toolsRelations = toolsRelations;
-exports.updateAgent = updateAgent;
 exports.updateAgentGraph = updateAgentGraph;
 exports.updateAgentRelation = updateAgentRelation;
 exports.updateAgentToolRelation = updateAgentToolRelation;
@@ -11692,9 +12018,9 @@ exports.updateFullGraphServerSide = updateFullGraphServerSide;
 exports.updateFullProjectServerSide = updateFullProjectServerSide;
 exports.updateMessage = updateMessage;
 exports.updateProject = updateProject;
+exports.updateSubAgent = updateSubAgent;
 exports.updateTask = updateTask;
 exports.updateTool = updateTool;
-exports.upsertAgent = upsertAgent;
 exports.upsertAgentArtifactComponentRelation = upsertAgentArtifactComponentRelation;
 exports.upsertAgentDataComponentRelation = upsertAgentDataComponentRelation;
 exports.upsertAgentGraph = upsertAgentGraph;
@@ -11707,6 +12033,7 @@ exports.upsertDataComponent = upsertDataComponent;
 exports.upsertExternalAgent = upsertExternalAgent;
 exports.upsertFunction = upsertFunction;
 exports.upsertLedgerArtifact = upsertLedgerArtifact;
+exports.upsertSubAgent = upsertSubAgent;
 exports.upsertTool = upsertTool;
 exports.validateAgainstJsonSchema = validateAgainstJsonSchema;
 exports.validateAgentRelationships = validateAgentRelationships;
@@ -11719,7 +12046,7 @@ exports.validateExternalAgent = validateExternalAgent;
 exports.validateGraphStructure = validateGraphStructure;
 exports.validateHeaders = validateHeaders;
 exports.validateHttpRequestHeaders = validateHttpRequestHeaders;
-exports.validateInternalAgent = validateInternalAgent;
+exports.validateInternalSubAgent = validateInternalSubAgent;
 exports.validateProjectExists = validateProjectExists;
 exports.validatePropsAsJsonSchema = validatePropsAsJsonSchema;
 exports.validateToolReferences = validateToolReferences;