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

package/dist/index.js

@@ -1,12 +1,13 @@
+export { ACTIVITY_NAMES, ACTIVITY_STATUS, ACTIVITY_TYPES, AGENT_IDS, AGGREGATE_OPERATORS, AI_OPERATIONS, AI_TOOL_TYPES, DATA_SOURCES, DATA_TYPES, DELEGATION_FROM_SUB_AGENT_ID, DELEGATION_ID, DELEGATION_TO_SUB_AGENT_ID, FIELD_TYPES, OPERATORS, ORDER_DIRECTIONS, PANEL_TYPES, QUERY_DEFAULTS, QUERY_EXPRESSIONS, QUERY_FIELD_CONFIGS, QUERY_TYPES, REDUCE_OPERATIONS, SPAN_KEYS, SPAN_NAMES, TOOL_NAMES, TRANSFER_FROM_SUB_AGENT_ID, TRANSFER_TO_SUB_AGENT_ID, UNKNOWN_VALUE } from './chunk-TCLX6C3C.js';
 export { TaskState } from './chunk-H2F72PDA.js';
 import { getLogger, convertZodToJsonSchema } from './chunk-R2EERZSW.js';
 export { PinoLogger, convertZodToJsonSchema, convertZodToJsonSchemaWithPreview, extractPreviewFields, getLogger, isZodSchema, loggerFactory, preview } from './chunk-R2EERZSW.js';
-import { validateAndTypeGraphData, validateGraphStructure, isInternalAgent, isExternalAgent } from './chunk-L53XWAYG.js';
-export { generateIdFromName, isExternalAgent, isInternalAgent, isValidResourceId, validateAgentRelationships, validateAndTypeGraphData, validateArtifactComponentReferences, validateDataComponentReferences, validateGraphStructure, validateToolReferences } from './chunk-L53XWAYG.js';
-import { ContextConfigApiUpdateSchema, validatePropsAsJsonSchema } from './chunk-TO2HNKGP.js';
-export { AgentApiInsertSchema, AgentApiSelectSchema, AgentApiUpdateSchema, AgentArtifactComponentApiInsertSchema, AgentArtifactComponentApiSelectSchema, AgentArtifactComponentApiUpdateSchema, AgentArtifactComponentInsertSchema, AgentArtifactComponentSelectSchema, AgentArtifactComponentUpdateSchema, AgentDataComponentApiInsertSchema, AgentDataComponentApiSelectSchema, AgentDataComponentApiUpdateSchema, AgentDataComponentInsertSchema, AgentDataComponentSelectSchema, AgentDataComponentUpdateSchema, AgentGraphApiInsertSchema, AgentGraphApiSelectSchema, AgentGraphApiUpdateSchema, AgentGraphInsertSchema, AgentGraphSelectSchema, AgentGraphUpdateSchema, AgentInsertSchema, AgentRelationApiInsertSchema, AgentRelationApiSelectSchema, AgentRelationApiUpdateSchema, AgentRelationInsertSchema, AgentRelationQuerySchema, AgentRelationSelectSchema, AgentRelationUpdateSchema, AgentSelectSchema, AgentStopWhenSchema, AgentToolRelationApiInsertSchema, AgentToolRelationApiSelectSchema, AgentToolRelationApiUpdateSchema, AgentToolRelationInsertSchema, AgentToolRelationSelectSchema, AgentToolRelationUpdateSchema, AgentUpdateSchema, AllAgentSchema, ApiKeyApiCreationResponseSchema, ApiKeyApiInsertSchema, ApiKeyApiSelectSchema, ApiKeyApiUpdateSchema, ApiKeyInsertSchema, ApiKeySelectSchema, ApiKeyUpdateSchema, ArtifactComponentApiInsertSchema, ArtifactComponentApiSelectSchema, ArtifactComponentApiUpdateSchema, ArtifactComponentInsertSchema, ArtifactComponentSelectSchema, ArtifactComponentUpdateSchema, CanUseItemSchema, ContextCacheApiInsertSchema, ContextCacheApiSelectSchema, ContextCacheApiUpdateSchema, ContextCacheInsertSchema, ContextCacheSelectSchema, ContextCacheUpdateSchema, ContextConfigApiInsertSchema, ContextConfigApiSelectSchema, ContextConfigApiUpdateSchema, ContextConfigInsertSchema, ContextConfigSelectSchema, ContextConfigUpdateSchema, ConversationApiInsertSchema, ConversationApiSelectSchema, ConversationApiUpdateSchema, ConversationInsertSchema, ConversationSelectSchema, ConversationUpdateSchema, CredentialReferenceApiInsertSchema, CredentialReferenceApiSelectSchema, CredentialReferenceApiUpdateSchema, CredentialReferenceInsertSchema, CredentialReferenceSelectSchema, CredentialReferenceUpdateSchema, DataComponentApiInsertSchema, DataComponentApiSelectSchema, DataComponentApiUpdateSchema, DataComponentBaseSchema, DataComponentInsertSchema, DataComponentSelectSchema, DataComponentUpdateSchema, ErrorResponseSchema, ExistsResponseSchema, ExternalAgentApiInsertSchema, ExternalAgentApiSelectSchema, ExternalAgentApiUpdateSchema, ExternalAgentInsertSchema, ExternalAgentRelationApiInsertSchema, ExternalAgentRelationInsertSchema, ExternalAgentSelectSchema, ExternalAgentUpdateSchema, FetchConfigSchema, FetchDefinitionSchema, FullGraphAgentInsertSchema, FullGraphDefinitionSchema, FullProjectDefinitionSchema, FunctionApiInsertSchema, FunctionApiSelectSchema, FunctionApiUpdateSchema, FunctionInsertSchema, FunctionSelectSchema, FunctionToolConfigSchema, FunctionUpdateSchema, GraphStopWhenSchema, GraphWithinContextOfProjectSchema, HeadersScopeSchema, IdParamsSchema, LedgerArtifactApiInsertSchema, LedgerArtifactApiSelectSchema, LedgerArtifactApiUpdateSchema, LedgerArtifactInsertSchema, LedgerArtifactSelectSchema, LedgerArtifactUpdateSchema, ListResponseSchema, MAX_ID_LENGTH, MCPToolConfigSchema, MIN_ID_LENGTH, McpToolDefinitionSchema, McpToolSchema, McpTransportConfigSchema, MessageApiInsertSchema, MessageApiSelectSchema, MessageApiUpdateSchema, MessageInsertSchema, MessageSelectSchema, MessageUpdateSchema, ModelSchema, ModelSettingsSchema, PaginationQueryParamsSchema, PaginationSchema, ProjectApiInsertSchema, ProjectApiSelectSchema, ProjectApiUpdateSchema, ProjectInsertSchema, ProjectModelSchema, ProjectSelectSchema, ProjectUpdateSchema, RemovedResponseSchema, SandboxConfigSchema, SingleResponseSchema, StatusComponentSchema, StatusUpdateSchema, StopWhenSchema, TaskApiInsertSchema, TaskApiSelectSchema, TaskApiUpdateSchema, TaskInsertSchema, TaskRelationApiInsertSchema, TaskRelationApiSelectSchema, TaskRelationApiUpdateSchema, TaskRelationInsertSchema, TaskRelationSelectSchema, TaskRelationUpdateSchema, TaskSelectSchema, TaskUpdateSchema, TenantIdParamsSchema, TenantParamsSchema, TenantProjectGraphIdParamsSchema, TenantProjectGraphParamsSchema, TenantProjectIdParamsSchema, TenantProjectParamsSchema, ToolApiInsertSchema, ToolApiSelectSchema, ToolApiUpdateSchema, ToolInsertSchema, ToolSelectSchema, ToolStatusSchema, ToolUpdateSchema, URL_SAFE_ID_PATTERN, resourceIdSchema, validatePropsAsJsonSchema } from './chunk-TO2HNKGP.js';
-import { schema_exports, agentRelations, agents, externalAgents, agentToolRelations, tools, contextConfigs, functions, credentialReferences, agentGraph, agentDataComponents, agentArtifactComponents, dataComponents, artifactComponents, projects, apiKeys, contextCache, conversations, messages, ledgerArtifacts, tasks, taskRelations } from './chunk-VPJ6Z5QZ.js';
-export { agentArtifactComponents, agentArtifactComponentsRelations, agentDataComponents, agentDataComponentsRelations, agentGraph, agentGraphRelations, agentRelations, agentRelationsRelations, agentToolRelations, agentToolRelationsRelations, agents, agentsRelations, apiKeys, apiKeysRelations, artifactComponents, artifactComponentsRelations, contextCache, contextCacheRelations, contextConfigs, contextConfigsRelations, conversations, conversationsRelations, credentialReferences, credentialReferencesRelations, dataComponents, dataComponentsRelations, externalAgents, externalAgentsRelations, functions, functionsRelations, ledgerArtifacts, ledgerArtifactsRelations, messages, messagesRelations, projects, projectsRelations, taskRelations, taskRelationsRelations, tasks, tasksRelations, tools, toolsRelations } from './chunk-VPJ6Z5QZ.js';
+import { validateAndTypeGraphData, validateGraphStructure, isInternalAgent, isExternalAgent } from './chunk-ZSQFZL3Y.js';
+export { A2AMessageMetadataSchema, DataOperationDetailsSchema, DataOperationEventSchema, DelegationReturnedDataSchema, DelegationSentDataSchema, TransferDataSchema, generateIdFromName, isExternalAgent, isInternalAgent, isValidResourceId, validateAgentRelationships, validateAndTypeGraphData, validateArtifactComponentReferences, validateDataComponentReferences, validateGraphStructure, validateToolReferences } from './chunk-ZSQFZL3Y.js';
+import { ContextConfigApiUpdateSchema, validatePropsAsJsonSchema } from './chunk-BVURASVM.js';
+export { AgentArtifactComponentApiInsertSchema, AgentArtifactComponentApiSelectSchema, AgentArtifactComponentApiUpdateSchema, AgentArtifactComponentInsertSchema, AgentArtifactComponentSelectSchema, AgentArtifactComponentUpdateSchema, AgentDataComponentApiInsertSchema, AgentDataComponentApiSelectSchema, AgentDataComponentApiUpdateSchema, AgentDataComponentInsertSchema, AgentDataComponentSelectSchema, AgentDataComponentUpdateSchema, AgentGraphApiInsertSchema, AgentGraphApiSelectSchema, AgentGraphApiUpdateSchema, AgentGraphInsertSchema, AgentGraphSelectSchema, AgentGraphUpdateSchema, AgentRelationApiInsertSchema, AgentRelationApiSelectSchema, AgentRelationApiUpdateSchema, AgentRelationInsertSchema, AgentRelationQuerySchema, AgentRelationSelectSchema, AgentRelationUpdateSchema, AgentStopWhenSchema, AgentToolRelationApiInsertSchema, AgentToolRelationApiSelectSchema, AgentToolRelationApiUpdateSchema, AgentToolRelationInsertSchema, AgentToolRelationSelectSchema, AgentToolRelationUpdateSchema, AllAgentSchema, ApiKeyApiCreationResponseSchema, ApiKeyApiInsertSchema, ApiKeyApiSelectSchema, ApiKeyApiUpdateSchema, ApiKeyInsertSchema, ApiKeySelectSchema, ApiKeyUpdateSchema, ArtifactComponentApiInsertSchema, ArtifactComponentApiSelectSchema, ArtifactComponentApiUpdateSchema, ArtifactComponentInsertSchema, ArtifactComponentSelectSchema, ArtifactComponentUpdateSchema, CanUseItemSchema, ContextCacheApiInsertSchema, ContextCacheApiSelectSchema, ContextCacheApiUpdateSchema, ContextCacheInsertSchema, ContextCacheSelectSchema, ContextCacheUpdateSchema, ContextConfigApiInsertSchema, ContextConfigApiSelectSchema, ContextConfigApiUpdateSchema, ContextConfigInsertSchema, ContextConfigSelectSchema, ContextConfigUpdateSchema, ConversationApiInsertSchema, ConversationApiSelectSchema, ConversationApiUpdateSchema, ConversationInsertSchema, ConversationSelectSchema, ConversationUpdateSchema, CredentialReferenceApiInsertSchema, CredentialReferenceApiSelectSchema, CredentialReferenceApiUpdateSchema, CredentialReferenceInsertSchema, CredentialReferenceSelectSchema, CredentialReferenceUpdateSchema, DataComponentApiInsertSchema, DataComponentApiSelectSchema, DataComponentApiUpdateSchema, DataComponentBaseSchema, DataComponentInsertSchema, DataComponentSelectSchema, DataComponentUpdateSchema, ErrorResponseSchema, ExistsResponseSchema, ExternalAgentApiInsertSchema, ExternalAgentApiSelectSchema, ExternalAgentApiUpdateSchema, ExternalAgentInsertSchema, ExternalAgentRelationApiInsertSchema, ExternalAgentRelationInsertSchema, ExternalAgentSelectSchema, ExternalAgentUpdateSchema, FetchConfigSchema, FetchDefinitionSchema, FullGraphAgentInsertSchema, FullProjectDefinitionSchema, FunctionApiInsertSchema, FunctionApiSelectSchema, FunctionApiUpdateSchema, FunctionInsertSchema, FunctionSelectSchema, FunctionToolConfigSchema, FunctionUpdateSchema, GraphStopWhenSchema, GraphWithinContextOfProjectSchema, HeadersScopeSchema, LedgerArtifactApiInsertSchema, LedgerArtifactApiSelectSchema, LedgerArtifactApiUpdateSchema, LedgerArtifactInsertSchema, LedgerArtifactSelectSchema, LedgerArtifactUpdateSchema, ListResponseSchema, MAX_ID_LENGTH, MCPToolConfigSchema, MIN_ID_LENGTH, McpToolDefinitionSchema, McpToolSchema, McpTransportConfigSchema, MessageApiInsertSchema, MessageApiSelectSchema, MessageApiUpdateSchema, MessageInsertSchema, MessageSelectSchema, MessageUpdateSchema, ModelSchema, ModelSettingsSchema, PaginationQueryParamsSchema, PaginationSchema, ProjectApiInsertSchema, ProjectApiSelectSchema, ProjectApiUpdateSchema, ProjectInsertSchema, ProjectModelSchema, ProjectSelectSchema, ProjectUpdateSchema, RemovedResponseSchema, SandboxConfigSchema, SingleResponseSchema, StatusComponentSchema, StatusUpdateSchema, StopWhenSchema, SubAgentApiInsertSchema, SubAgentApiSelectSchema, SubAgentApiUpdateSchema, SubAgentInsertSchema, SubAgentSelectSchema, SubAgentUpdateSchema, TaskApiInsertSchema, TaskApiSelectSchema, TaskApiUpdateSchema, TaskInsertSchema, TaskRelationApiInsertSchema, TaskRelationApiSelectSchema, TaskRelationApiUpdateSchema, TaskRelationInsertSchema, TaskRelationSelectSchema, TaskRelationUpdateSchema, TaskSelectSchema, TaskUpdateSchema, TenantIdParamsSchema, TenantParamsSchema, TenantProjectGraphIdParamsSchema, TenantProjectGraphParamsSchema, TenantProjectGraphSubAgentIdParamsSchema, TenantProjectGraphSubAgentParamsSchema, TenantProjectIdParamsSchema, TenantProjectParamsSchema, ToolApiInsertSchema, ToolApiSelectSchema, ToolApiUpdateSchema, ToolInsertSchema, ToolSelectSchema, ToolStatusSchema, ToolUpdateSchema, URL_SAFE_ID_PATTERN, resourceIdSchema, validatePropsAsJsonSchema } from './chunk-BVURASVM.js';
+import { schema_exports, contextConfigs, externalAgents, functions, subAgentRelations, subAgents, subAgentToolRelations, tools, credentialReferences, agentGraph, subAgentDataComponents, subAgentArtifactComponents, dataComponents, artifactComponents, projects, apiKeys, contextCache, conversations, messages, ledgerArtifacts, tasks, taskRelations } from './chunk-5LRSB445.js';
+export { agentGraph, agentGraphRelations, agentToolRelationsRelations, apiKeys, apiKeysRelations, artifactComponents, artifactComponentsRelations, contextCache, contextCacheRelations, contextConfigs, contextConfigsRelations, conversations, conversationsRelations, credentialReferences, credentialReferencesRelations, dataComponents, dataComponentsRelations, externalAgents, externalAgentsRelations, functions, functionsRelations, ledgerArtifacts, ledgerArtifactsRelations, messages, messagesRelations, projects, projectsRelations, subAgentArtifactComponents, subAgentArtifactComponentsRelations, subAgentDataComponents, subAgentDataComponentsRelations, subAgentRelations, subAgentRelationsRelations, subAgentToolRelations, subAgents, subAgentsRelations, taskRelations, taskRelationsRelations, tasks, tasksRelations, tools, toolsRelations } from './chunk-5LRSB445.js';
 import { CredentialStoreType, MCPServerType, MCPTransportType } from './chunk-YFHT5M2R.js';
 export { CredentialStoreType, MCPServerType, MCPTransportType, TOOL_STATUS_VALUES, VALID_RELATION_TYPES } from './chunk-YFHT5M2R.js';
 import { __publicField } from './chunk-MKBO26DX.js';
@@ -15,7 +16,7 @@ import { customAlphabet, nanoid } from 'nanoid';
 import jmespath from 'jmespath';
 import { createClient } from '@libsql/client';
 import { drizzle } from 'drizzle-orm/libsql';
-import { and, eq, desc, count, isNotNull, inArray, sql, asc, not } from 'drizzle-orm';
+import { and, eq, desc, sql, count, asc, isNotNull, inArray, not } from 'drizzle-orm';
 import crypto, { scrypt, randomBytes, timingSafeEqual } from 'crypto';
 import { promisify } from 'util';
 import { z } from '@hono/zod-openapi';
@@ -753,13 +754,373 @@ function createInMemoryDatabaseClient() {
   const db = createDatabaseClient({ url: ":memory:" });
   return db;
 }
+var getContextConfigById = (db) => async (params) => {
+  return await db.query.contextConfigs.findFirst({
+    where: and(
+      eq(contextConfigs.tenantId, params.scopes.tenantId),
+      eq(contextConfigs.projectId, params.scopes.projectId),
+      eq(contextConfigs.graphId, params.scopes.graphId),
+      eq(contextConfigs.id, params.id)
+    )
+  });
+};
+var listContextConfigs = (db) => async (params) => {
+  return await db.query.contextConfigs.findMany({
+    where: and(
+      eq(contextConfigs.tenantId, params.scopes.tenantId),
+      eq(contextConfigs.projectId, params.scopes.projectId),
+      eq(contextConfigs.graphId, params.scopes.graphId)
+    ),
+    orderBy: [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 = and(
+    eq(contextConfigs.tenantId, params.scopes.tenantId),
+    eq(contextConfigs.projectId, params.scopes.projectId),
+    eq(contextConfigs.graphId, params.scopes.graphId)
+  );
+  const [contextConfigList, totalResult] = await Promise.all([
+    db.select().from(contextConfigs).where(whereClause).limit(limit).offset(offset).orderBy(desc(contextConfigs.createdAt)),
+    db.select({ count: 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();
+  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(
+    and(
+      eq(contextConfigs.tenantId, params.scopes.tenantId),
+      eq(contextConfigs.projectId, params.scopes.projectId),
+      eq(contextConfigs.graphId, params.scopes.graphId),
+      eq(contextConfigs.id, params.id)
+    )
+  ).returning();
+  return updated[0];
+};
+var deleteContextConfig = (db) => async (params) => {
+  try {
+    const result = await db.delete(contextConfigs).where(
+      and(
+        eq(contextConfigs.tenantId, params.scopes.tenantId),
+        eq(contextConfigs.projectId, params.scopes.projectId),
+        eq(contextConfigs.graphId, params.scopes.graphId),
+        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: count() }).from(contextConfigs).where(
+    and(
+      eq(contextConfigs.tenantId, params.scopes.tenantId),
+      eq(contextConfigs.projectId, params.scopes.projectId),
+      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: and(
+      eq(externalAgents.tenantId, params.scopes.tenantId),
+      eq(externalAgents.projectId, params.scopes.projectId),
+      eq(externalAgents.graphId, params.scopes.graphId),
+      eq(externalAgents.id, params.subAgentId)
+    )
+  });
+  return result || null;
+};
+var getExternalAgentByUrl = (db) => async (params) => {
+  const result = await db.query.externalAgents.findFirst({
+    where: and(
+      eq(externalAgents.tenantId, params.scopes.tenantId),
+      eq(externalAgents.projectId, params.scopes.projectId),
+      eq(externalAgents.graphId, params.scopes.graphId),
+      eq(externalAgents.baseUrl, params.baseUrl)
+    )
+  });
+  return result || null;
+};
+var listExternalAgents = (db) => async (params) => {
+  return await db.query.externalAgents.findMany({
+    where: and(
+      eq(externalAgents.tenantId, params.scopes.tenantId),
+      eq(externalAgents.projectId, params.scopes.projectId),
+      eq(externalAgents.graphId, params.scopes.graphId)
+    ),
+    orderBy: [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(
+      and(
+        eq(externalAgents.tenantId, params.scopes.tenantId),
+        eq(externalAgents.projectId, params.scopes.projectId),
+        eq(externalAgents.graphId, params.scopes.graphId)
+      )
+    ).limit(limit).offset(offset).orderBy(desc(externalAgents.createdAt)),
+    db.select({ count: count() }).from(externalAgents).where(
+      and(
+        eq(externalAgents.tenantId, params.scopes.tenantId),
+        eq(externalAgents.projectId, params.scopes.projectId),
+        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(
+    and(
+      eq(externalAgents.tenantId, params.scopes.tenantId),
+      eq(externalAgents.projectId, params.scopes.projectId),
+      eq(externalAgents.graphId, params.scopes.graphId),
+      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(
+      and(
+        eq(externalAgents.tenantId, params.scopes.tenantId),
+        eq(externalAgents.projectId, params.scopes.projectId),
+        eq(externalAgents.graphId, params.scopes.graphId),
+        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: count() }).from(externalAgents).where(
+    and(
+      eq(externalAgents.tenantId, params.scopes.tenantId),
+      eq(externalAgents.projectId, params.scopes.projectId),
+      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(
+    and(
+      eq(functions.tenantId, tenantId),
+      eq(functions.projectId, projectId),
+      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(
+      and(
+        eq(functions.tenantId, tenantId),
+        eq(functions.projectId, projectId),
+        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(
+    and(
+      eq(functions.tenantId, tenantId),
+      eq(functions.projectId, projectId),
+      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(and(eq(functions.tenantId, tenantId), eq(functions.projectId, projectId)));
+  return result;
+};
+var deleteFunction = (db) => async (params) => {
+  const { functionId, scopes } = params;
+  const { tenantId, projectId } = scopes;
+  await db.delete(functions).where(
+    and(
+      eq(functions.tenantId, tenantId),
+      eq(functions.projectId, projectId),
+      eq(functions.id, functionId)
+    )
+  );
+};
 var getAgentRelationById = (db) => async (params) => {
-  return db.query.agentRelations.findFirst({
+  return db.query.subAgentRelations.findFirst({
     where: and(
-      eq(agentRelations.tenantId, params.scopes.tenantId),
-      eq(agentRelations.projectId, params.scopes.projectId),
-      eq(agentRelations.graphId, params.scopes.graphId),
-      eq(agentRelations.id, params.relationId)
+      eq(subAgentRelations.tenantId, params.scopes.tenantId),
+      eq(subAgentRelations.projectId, params.scopes.projectId),
+      eq(subAgentRelations.graphId, params.scopes.graphId),
+      eq(subAgentRelations.id, params.relationId)
     )
   });
 };
@@ -768,34 +1129,34 @@ var listAgentRelations = (db) => async (params) => {
   const limit = Math.min(params.pagination?.limit || 10, 100);
   const offset = (page - 1) * limit;
   const whereClause = and(
-    eq(agentRelations.tenantId, params.scopes.tenantId),
-    eq(agentRelations.projectId, params.scopes.projectId),
-    eq(agentRelations.graphId, params.scopes.graphId)
+    eq(subAgentRelations.tenantId, params.scopes.tenantId),
+    eq(subAgentRelations.projectId, params.scopes.projectId),
+    eq(subAgentRelations.graphId, params.scopes.graphId)
   );
   const [data, totalResult] = await Promise.all([
-    db.select().from(agentRelations).where(whereClause).limit(limit).offset(offset).orderBy(desc(agentRelations.createdAt)),
-    db.select({ count: count() }).from(agentRelations).where(whereClause)
+    db.select().from(subAgentRelations).where(whereClause).limit(limit).offset(offset).orderBy(desc(subAgentRelations.createdAt)),
+    db.select({ count: 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.agentRelations.findMany({
+  return await db.query.subAgentRelations.findMany({
     where: and(
-      eq(agentRelations.tenantId, params.scopes.tenantId),
-      eq(agentRelations.projectId, params.scopes.projectId),
-      eq(agentRelations.graphId, params.scopes.graphId),
-      eq(agentRelations.sourceAgentId, params.scopes.agentId)
+      eq(subAgentRelations.tenantId, params.scopes.tenantId),
+      eq(subAgentRelations.projectId, params.scopes.projectId),
+      eq(subAgentRelations.graphId, params.scopes.graphId),
+      eq(subAgentRelations.sourceSubAgentId, params.scopes.subAgentId)
     )
   });
 };
 var getAgentRelationsByGraph = (db) => async (params) => {
-  return await db.query.agentRelations.findMany({
+  return await db.query.subAgentRelations.findMany({
     where: and(
-      eq(agentRelations.tenantId, params.scopes.tenantId),
-      eq(agentRelations.projectId, params.scopes.projectId),
-      eq(agentRelations.graphId, params.scopes.graphId)
+      eq(subAgentRelations.tenantId, params.scopes.tenantId),
+      eq(subAgentRelations.projectId, params.scopes.projectId),
+      eq(subAgentRelations.graphId, params.scopes.graphId)
     )
   });
 };
@@ -804,14 +1165,14 @@ var getAgentRelationsBySource = (db) => async (params) => {
   const limit = Math.min(params.pagination?.limit || 10, 100);
   const offset = (page - 1) * limit;
   const whereClause = and(
-    eq(agentRelations.tenantId, params.scopes.tenantId),
-    eq(agentRelations.projectId, params.scopes.projectId),
-    eq(agentRelations.graphId, params.scopes.graphId),
-    eq(agentRelations.sourceAgentId, params.sourceAgentId)
+    eq(subAgentRelations.tenantId, params.scopes.tenantId),
+    eq(subAgentRelations.projectId, params.scopes.projectId),
+    eq(subAgentRelations.graphId, params.scopes.graphId),
+    eq(subAgentRelations.sourceSubAgentId, params.sourceSubAgentId)
   );
   const [data, totalResult] = await Promise.all([
-    db.select().from(agentRelations).where(whereClause).limit(limit).offset(offset).orderBy(desc(agentRelations.createdAt)),
-    db.select({ count: count() }).from(agentRelations).where(whereClause)
+    db.select().from(subAgentRelations).where(whereClause).limit(limit).offset(offset).orderBy(desc(subAgentRelations.createdAt)),
+    db.select({ count: count() }).from(subAgentRelations).where(whereClause)
   ]);
   const total = totalResult[0]?.count || 0;
   const pages = Math.ceil(total / limit);
@@ -825,14 +1186,14 @@ var getAgentRelationsByTarget = (db) => async (params) => {
   const limit = Math.min(params.pagination?.limit || 10, 100);
   const offset = (page - 1) * limit;
   const whereClause = and(
-    eq(agentRelations.tenantId, params.scopes.tenantId),
-    eq(agentRelations.projectId, params.scopes.projectId),
-    eq(agentRelations.graphId, params.scopes.graphId),
-    eq(agentRelations.targetAgentId, params.targetAgentId)
+    eq(subAgentRelations.tenantId, params.scopes.tenantId),
+    eq(subAgentRelations.projectId, params.scopes.projectId),
+    eq(subAgentRelations.graphId, params.scopes.graphId),
+    eq(subAgentRelations.targetSubAgentId, params.targetSubAgentId)
   );
   const [data, totalResult] = await Promise.all([
-    db.select().from(agentRelations).where(whereClause).limit(limit).offset(offset).orderBy(desc(agentRelations.createdAt)),
-    db.select({ count: count() }).from(agentRelations).where(whereClause)
+    db.select().from(subAgentRelations).where(whereClause).limit(limit).offset(offset).orderBy(desc(subAgentRelations.createdAt)),
+    db.select({ count: count() }).from(subAgentRelations).where(whereClause)
   ]);
   const total = totalResult[0]?.count || 0;
   const pages = Math.ceil(total / limit);
@@ -846,14 +1207,14 @@ var getExternalAgentRelations = (db) => async (params) => {
   const limit = Math.min(params.pagination?.limit || 10, 100);
   const offset = (page - 1) * limit;
   const whereClause = and(
-    eq(agentRelations.tenantId, params.scopes.tenantId),
-    eq(agentRelations.projectId, params.scopes.projectId),
-    eq(agentRelations.graphId, params.scopes.graphId),
-    eq(agentRelations.externalAgentId, params.externalAgentId)
+    eq(subAgentRelations.tenantId, params.scopes.tenantId),
+    eq(subAgentRelations.projectId, params.scopes.projectId),
+    eq(subAgentRelations.graphId, params.scopes.graphId),
+    eq(subAgentRelations.externalSubAgentId, params.externalSubAgentId)
   );
   const [data, totalResult] = await Promise.all([
-    db.select().from(agentRelations).where(whereClause).limit(limit).offset(offset).orderBy(desc(agentRelations.createdAt)),
-    db.select({ count: count() }).from(agentRelations).where(whereClause)
+    db.select().from(subAgentRelations).where(whereClause).limit(limit).offset(offset).orderBy(desc(subAgentRelations.createdAt)),
+    db.select({ count: count() }).from(subAgentRelations).where(whereClause)
   ]);
   const total = totalResult[0]?.count || 0;
   const pages = Math.ceil(total / limit);
@@ -864,51 +1225,51 @@ var getExternalAgentRelations = (db) => async (params) => {
 };
 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,
+    id: subAgents.id,
+    name: subAgents.name,
+    description: subAgents.description,
+    relationType: subAgentRelations.relationType
+  }).from(subAgentRelations).innerJoin(
+    subAgents,
     and(
-      eq(agentRelations.targetAgentId, agents.id),
-      eq(agentRelations.tenantId, agents.tenantId),
-      eq(agentRelations.projectId, agents.projectId),
-      eq(agentRelations.graphId, agents.graphId)
+      eq(subAgentRelations.targetSubAgentId, subAgents.id),
+      eq(subAgentRelations.tenantId, subAgents.tenantId),
+      eq(subAgentRelations.projectId, subAgents.projectId),
+      eq(subAgentRelations.graphId, subAgents.graphId)
     )
   ).where(
     and(
-      eq(agentRelations.tenantId, params.scopes.tenantId),
-      eq(agentRelations.projectId, params.scopes.projectId),
-      eq(agentRelations.graphId, params.scopes.graphId),
-      eq(agentRelations.sourceAgentId, params.agentId),
-      isNotNull(agentRelations.targetAgentId)
+      eq(subAgentRelations.tenantId, params.scopes.tenantId),
+      eq(subAgentRelations.projectId, params.scopes.projectId),
+      eq(subAgentRelations.graphId, params.scopes.graphId),
+      eq(subAgentRelations.sourceSubAgentId, params.subAgentId),
+      isNotNull(subAgentRelations.targetSubAgentId)
     )
   );
   const externalRelations = await db.select({
-    id: agentRelations.id,
-    relationType: agentRelations.relationType,
+    id: subAgentRelations.id,
+    relationType: subAgentRelations.relationType,
     externalAgent: {
       id: externalAgents.id,
       name: externalAgents.name,
       description: externalAgents.description,
       baseUrl: externalAgents.baseUrl
     }
-  }).from(agentRelations).innerJoin(
+  }).from(subAgentRelations).innerJoin(
     externalAgents,
     and(
-      eq(agentRelations.externalAgentId, externalAgents.id),
-      eq(agentRelations.tenantId, externalAgents.tenantId),
-      eq(agentRelations.projectId, externalAgents.projectId),
-      eq(agentRelations.graphId, externalAgents.graphId)
+      eq(subAgentRelations.externalSubAgentId, externalAgents.id),
+      eq(subAgentRelations.tenantId, externalAgents.tenantId),
+      eq(subAgentRelations.projectId, externalAgents.projectId),
+      eq(subAgentRelations.graphId, externalAgents.graphId)
     )
   ).where(
     and(
-      eq(agentRelations.tenantId, params.scopes.tenantId),
-      eq(agentRelations.projectId, params.scopes.projectId),
-      eq(agentRelations.graphId, params.scopes.graphId),
-      eq(agentRelations.sourceAgentId, params.agentId),
-      isNotNull(agentRelations.externalAgentId)
+      eq(subAgentRelations.tenantId, params.scopes.tenantId),
+      eq(subAgentRelations.projectId, params.scopes.projectId),
+      eq(subAgentRelations.graphId, params.scopes.graphId),
+      eq(subAgentRelations.sourceSubAgentId, params.subAgentId),
+      isNotNull(subAgentRelations.externalSubAgentId)
     )
   );
   return {
@@ -916,55 +1277,55 @@ var getRelatedAgentsForGraph = (db) => async (params) => {
     externalRelations
   };
 };
-var createAgentRelation = (db) => async (params) => {
-  const hasTargetAgent = params.targetAgentId != null;
-  const hasExternalAgent = params.externalAgentId != null;
+var createSubAgentRelation = (db) => async (params) => {
+  const hasTargetAgent = params.targetSubAgentId != null;
+  const hasExternalAgent = params.externalSubAgentId != null;
   if (hasTargetAgent && hasExternalAgent) {
-    throw new Error("Cannot specify both targetAgentId and externalAgentId");
+    throw new Error("Cannot specify both targetSubAgentId and externalSubAgentId");
   }
   if (!hasTargetAgent && !hasExternalAgent) {
-    throw new Error("Must specify either targetAgentId or externalAgentId");
+    throw new Error("Must specify either targetSubAgentId or externalSubAgentId");
   }
-  const relation = await db.insert(agentRelations).values({
+  const relation = await db.insert(subAgentRelations).values({
     ...params
   }).returning();
   return relation[0];
 };
 var getAgentRelationByParams = (db) => async (params) => {
   const whereConditions = [
-    eq(agentRelations.tenantId, params.scopes.tenantId),
-    eq(agentRelations.projectId, params.scopes.projectId),
-    eq(agentRelations.graphId, params.scopes.graphId),
-    eq(agentRelations.sourceAgentId, params.sourceAgentId),
-    eq(agentRelations.relationType, params.relationType)
+    eq(subAgentRelations.tenantId, params.scopes.tenantId),
+    eq(subAgentRelations.projectId, params.scopes.projectId),
+    eq(subAgentRelations.graphId, params.scopes.graphId),
+    eq(subAgentRelations.sourceSubAgentId, params.sourceSubAgentId),
+    eq(subAgentRelations.relationType, params.relationType)
   ];
-  if (params.targetAgentId) {
-    whereConditions.push(eq(agentRelations.targetAgentId, params.targetAgentId));
+  if (params.targetSubAgentId) {
+    whereConditions.push(eq(subAgentRelations.targetSubAgentId, params.targetSubAgentId));
   }
-  if (params.externalAgentId) {
-    whereConditions.push(eq(agentRelations.externalAgentId, params.externalAgentId));
+  if (params.externalSubAgentId) {
+    whereConditions.push(eq(subAgentRelations.externalSubAgentId, params.externalSubAgentId));
   }
-  return db.query.agentRelations.findFirst({
+  return db.query.subAgentRelations.findFirst({
     where: 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,
+    sourceSubAgentId: params.sourceSubAgentId,
+    targetSubAgentId: params.targetSubAgentId,
+    externalSubAgentId: params.externalSubAgentId,
     relationType: params.relationType ?? ""
   });
   if (!existing) {
-    return await createAgentRelation(db)(params);
+    return await createSubAgentRelation(db)(params);
   }
   return existing;
 };
 var createExternalAgentRelation = (db) => async (params) => {
-  return await createAgentRelation(db)({
+  return await createSubAgentRelation(db)({
     ...params,
-    targetAgentId: void 0
+    targetSubAgentId: void 0
   });
 };
 var updateAgentRelation = (db) => async (params) => {
@@ -972,44 +1333,44 @@ var updateAgentRelation = (db) => async (params) => {
     ...params.data,
     updatedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
-  const relation = await db.update(agentRelations).set(updateData).where(
+  const relation = await db.update(subAgentRelations).set(updateData).where(
     and(
-      eq(agentRelations.tenantId, params.scopes.tenantId),
-      eq(agentRelations.projectId, params.scopes.projectId),
-      eq(agentRelations.graphId, params.scopes.graphId),
-      eq(agentRelations.id, params.relationId)
+      eq(subAgentRelations.tenantId, params.scopes.tenantId),
+      eq(subAgentRelations.projectId, params.scopes.projectId),
+      eq(subAgentRelations.graphId, params.scopes.graphId),
+      eq(subAgentRelations.id, params.relationId)
     )
   ).returning();
   return relation[0];
 };
-var deleteAgentRelation = (db) => async (params) => {
-  const result = await db.delete(agentRelations).where(
+var deleteSubAgentRelation = (db) => async (params) => {
+  const result = await db.delete(subAgentRelations).where(
     and(
-      eq(agentRelations.tenantId, params.scopes.tenantId),
-      eq(agentRelations.projectId, params.scopes.projectId),
-      eq(agentRelations.graphId, params.scopes.graphId),
-      eq(agentRelations.id, params.relationId)
+      eq(subAgentRelations.tenantId, params.scopes.tenantId),
+      eq(subAgentRelations.projectId, params.scopes.projectId),
+      eq(subAgentRelations.graphId, params.scopes.graphId),
+      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(
     and(
-      eq(agentRelations.tenantId, params.scopes.tenantId),
-      eq(agentRelations.graphId, params.scopes.graphId)
+      eq(subAgentRelations.tenantId, params.scopes.tenantId),
+      eq(subAgentRelations.graphId, params.scopes.graphId)
     )
   );
   return (result.rowsAffected || 0) > 0;
 };
 var createAgentToolRelation = (db) => async (params) => {
   const finalRelationId = params.relationId ?? 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
@@ -1021,45 +1382,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(
     and(
-      eq(agentToolRelations.tenantId, params.scopes.tenantId),
-      eq(agentToolRelations.projectId, params.scopes.projectId),
-      eq(agentToolRelations.graphId, params.scopes.graphId),
-      eq(agentToolRelations.id, params.relationId)
+      eq(subAgentToolRelations.tenantId, params.scopes.tenantId),
+      eq(subAgentToolRelations.projectId, params.scopes.projectId),
+      eq(subAgentToolRelations.graphId, params.scopes.graphId),
+      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(
     and(
-      eq(agentToolRelations.tenantId, params.scopes.tenantId),
-      eq(agentToolRelations.projectId, params.scopes.projectId),
-      eq(agentToolRelations.graphId, params.scopes.graphId),
-      eq(agentToolRelations.id, params.relationId)
+      eq(subAgentToolRelations.tenantId, params.scopes.tenantId),
+      eq(subAgentToolRelations.projectId, params.scopes.projectId),
+      eq(subAgentToolRelations.graphId, params.scopes.graphId),
+      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(
     and(
-      eq(agentToolRelations.tenantId, params.scopes.tenantId),
-      eq(agentToolRelations.projectId, params.scopes.projectId),
-      eq(agentToolRelations.graphId, params.scopes.graphId),
-      eq(agentToolRelations.agentId, params.scopes.agentId)
+      eq(subAgentToolRelations.tenantId, params.scopes.tenantId),
+      eq(subAgentToolRelations.projectId, params.scopes.projectId),
+      eq(subAgentToolRelations.graphId, params.scopes.graphId),
+      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: and(
-      eq(agentToolRelations.tenantId, params.scopes.tenantId),
-      eq(agentToolRelations.projectId, params.scopes.projectId),
-      eq(agentToolRelations.graphId, params.scopes.graphId),
-      eq(agentToolRelations.id, params.relationId)
+      eq(subAgentToolRelations.tenantId, params.scopes.tenantId),
+      eq(subAgentToolRelations.projectId, params.scopes.projectId),
+      eq(subAgentToolRelations.graphId, params.scopes.graphId),
+      eq(subAgentToolRelations.id, params.relationId)
     )
   });
 };
@@ -1068,18 +1429,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(
       and(
-        eq(agentToolRelations.tenantId, params.scopes.tenantId),
-        eq(agentToolRelations.projectId, params.scopes.projectId),
-        eq(agentToolRelations.agentId, params.scopes.agentId)
+        eq(subAgentToolRelations.tenantId, params.scopes.tenantId),
+        eq(subAgentToolRelations.projectId, params.scopes.projectId),
+        eq(subAgentToolRelations.subAgentId, params.scopes.subAgentId)
       )
-    ).limit(limit).offset(offset).orderBy(desc(agentToolRelations.createdAt)),
-    db.select({ count: count() }).from(agentToolRelations).where(
+    ).limit(limit).offset(offset).orderBy(desc(subAgentToolRelations.createdAt)),
+    db.select({ count: count() }).from(subAgentToolRelations).where(
       and(
-        eq(agentToolRelations.tenantId, params.scopes.tenantId),
-        eq(agentToolRelations.projectId, params.scopes.projectId),
-        eq(agentToolRelations.agentId, params.scopes.agentId)
+        eq(subAgentToolRelations.tenantId, params.scopes.tenantId),
+        eq(subAgentToolRelations.projectId, params.scopes.projectId),
+        eq(subAgentToolRelations.subAgentId, params.scopes.subAgentId)
       )
     )
   ]);
@@ -1095,20 +1456,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(
       and(
-        eq(agentToolRelations.tenantId, params.scopes.tenantId),
-        eq(agentToolRelations.projectId, params.scopes.projectId),
-        eq(agentToolRelations.graphId, params.scopes.graphId),
-        eq(agentToolRelations.toolId, params.toolId)
+        eq(subAgentToolRelations.tenantId, params.scopes.tenantId),
+        eq(subAgentToolRelations.projectId, params.scopes.projectId),
+        eq(subAgentToolRelations.graphId, params.scopes.graphId),
+        eq(subAgentToolRelations.toolId, params.toolId)
       )
-    ).limit(limit).offset(offset).orderBy(desc(agentToolRelations.createdAt)),
-    db.select({ count: count() }).from(agentToolRelations).where(
+    ).limit(limit).offset(offset).orderBy(desc(subAgentToolRelations.createdAt)),
+    db.select({ count: count() }).from(subAgentToolRelations).where(
       and(
-        eq(agentToolRelations.tenantId, params.scopes.tenantId),
-        eq(agentToolRelations.projectId, params.scopes.projectId),
-        eq(agentToolRelations.graphId, params.scopes.graphId),
-        eq(agentToolRelations.toolId, params.toolId)
+        eq(subAgentToolRelations.tenantId, params.scopes.tenantId),
+        eq(subAgentToolRelations.projectId, params.scopes.projectId),
+        eq(subAgentToolRelations.graphId, params.scopes.graphId),
+        eq(subAgentToolRelations.toolId, params.toolId)
       )
     )
   ]);
@@ -1124,18 +1485,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(
       and(
-        eq(agentToolRelations.tenantId, params.scopes.tenantId),
-        eq(agentToolRelations.projectId, params.scopes.projectId),
-        eq(agentToolRelations.graphId, params.scopes.graphId)
+        eq(subAgentToolRelations.tenantId, params.scopes.tenantId),
+        eq(subAgentToolRelations.projectId, params.scopes.projectId),
+        eq(subAgentToolRelations.graphId, params.scopes.graphId)
       )
-    ).limit(limit).offset(offset).orderBy(desc(agentToolRelations.createdAt)),
-    db.select({ count: count() }).from(agentToolRelations).where(
+    ).limit(limit).offset(offset).orderBy(desc(subAgentToolRelations.createdAt)),
+    db.select({ count: count() }).from(subAgentToolRelations).where(
       and(
-        eq(agentToolRelations.tenantId, params.scopes.tenantId),
-        eq(agentToolRelations.projectId, params.scopes.projectId),
-        eq(agentToolRelations.graphId, params.scopes.graphId)
+        eq(subAgentToolRelations.tenantId, params.scopes.tenantId),
+        eq(subAgentToolRelations.projectId, params.scopes.projectId),
+        eq(subAgentToolRelations.graphId, params.scopes.graphId)
       )
     )
   ]);
@@ -1152,14 +1513,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,
@@ -1176,27 +1537,27 @@ var getToolsForAgent = (db) => async (params) => {
         headers: tools.headers,
         imageUrl: tools.imageUrl
       }
-    }).from(agentToolRelations).innerJoin(
+    }).from(subAgentToolRelations).innerJoin(
       tools,
       and(
-        eq(agentToolRelations.tenantId, tools.tenantId),
-        eq(agentToolRelations.projectId, tools.projectId),
-        eq(agentToolRelations.toolId, tools.id)
+        eq(subAgentToolRelations.tenantId, tools.tenantId),
+        eq(subAgentToolRelations.projectId, tools.projectId),
+        eq(subAgentToolRelations.toolId, tools.id)
       )
     ).where(
       and(
-        eq(agentToolRelations.tenantId, params.scopes.tenantId),
-        eq(agentToolRelations.projectId, params.scopes.projectId),
-        eq(agentToolRelations.graphId, params.scopes.graphId),
-        eq(agentToolRelations.agentId, params.scopes.agentId)
+        eq(subAgentToolRelations.tenantId, params.scopes.tenantId),
+        eq(subAgentToolRelations.projectId, params.scopes.projectId),
+        eq(subAgentToolRelations.graphId, params.scopes.graphId),
+        eq(subAgentToolRelations.subAgentId, params.scopes.subAgentId)
       )
-    ).limit(limit).offset(offset).orderBy(desc(agentToolRelations.createdAt)),
-    db.select({ count: count() }).from(agentToolRelations).where(
+    ).limit(limit).offset(offset).orderBy(desc(subAgentToolRelations.createdAt)),
+    db.select({ count: count() }).from(subAgentToolRelations).where(
       and(
-        eq(agentToolRelations.tenantId, params.scopes.tenantId),
-        eq(agentToolRelations.projectId, params.scopes.projectId),
-        eq(agentToolRelations.graphId, params.scopes.graphId),
-        eq(agentToolRelations.agentId, params.scopes.agentId)
+        eq(subAgentToolRelations.tenantId, params.scopes.tenantId),
+        eq(subAgentToolRelations.projectId, params.scopes.projectId),
+        eq(subAgentToolRelations.graphId, params.scopes.graphId),
+        eq(subAgentToolRelations.subAgentId, params.scopes.subAgentId)
       )
     )
   ]);
@@ -1213,560 +1574,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,
-      and(
-        eq(agentToolRelations.agentId, agents.id),
-        eq(agentToolRelations.tenantId, agents.tenantId),
-        eq(agentToolRelations.projectId, agents.projectId),
-        eq(agentToolRelations.graphId, agents.graphId)
-      )
-    ).where(
-      and(
-        eq(agentToolRelations.tenantId, params.scopes.tenantId),
-        eq(agentToolRelations.projectId, params.scopes.projectId),
-        eq(agentToolRelations.graphId, params.scopes.graphId),
-        eq(agentToolRelations.toolId, params.toolId)
-      )
-    ).limit(limit).offset(offset).orderBy(desc(agentToolRelations.createdAt)),
-    db.select({ count: count() }).from(agentToolRelations).where(
+      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,
       and(
-        eq(agentToolRelations.tenantId, params.scopes.tenantId),
-        eq(agentToolRelations.projectId, params.scopes.projectId),
-        eq(agentToolRelations.graphId, params.scopes.graphId),
-        eq(agentToolRelations.toolId, params.toolId)
+        eq(subAgentToolRelations.subAgentId, subAgents.id),
+        eq(subAgentToolRelations.tenantId, subAgents.tenantId),
+        eq(subAgentToolRelations.projectId, subAgents.projectId),
+        eq(subAgentToolRelations.graphId, subAgents.graphId)
       )
-    )
-  ]);
-  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(
-    and(
-      eq(agents.tenantId, params.scopes.tenantId),
-      eq(agents.projectId, params.scopes.projectId),
-      eq(agents.graphId, params.scopes.graphId),
-      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(
-    and(
-      eq(externalAgents.tenantId, params.scopes.tenantId),
-      eq(externalAgents.projectId, params.scopes.projectId),
-      eq(externalAgents.graphId, params.scopes.graphId),
-      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: and(
-      eq(agents.tenantId, params.scopes.tenantId),
-      eq(agents.projectId, params.scopes.projectId),
-      eq(agents.graphId, params.scopes.graphId),
-      eq(agents.id, params.agentId)
-    )
-  });
-  return result;
-};
-var listAgents = (db) => async (params) => {
-  return await db.query.agents.findMany({
-    where: and(
-      eq(agents.tenantId, params.scopes.tenantId),
-      eq(agents.projectId, params.scopes.projectId),
-      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 = and(
-    eq(agents.tenantId, params.scopes.tenantId),
-    eq(agents.projectId, params.scopes.projectId),
-    eq(agents.graphId, params.scopes.graphId)
-  );
-  const [data, totalResult] = await Promise.all([
-    db.select().from(agents).where(whereClause).limit(limit).offset(offset).orderBy(desc(agents.createdAt)),
-    db.select({ count: 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(
-    and(
-      eq(agents.tenantId, params.scopes.tenantId),
-      eq(agents.projectId, params.scopes.projectId),
-      eq(agents.graphId, params.scopes.graphId),
-      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(
-    and(
-      eq(agents.tenantId, params.scopes.tenantId),
-      eq(agents.projectId, params.scopes.projectId),
-      eq(agents.graphId, params.scopes.graphId),
-      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(
-    and(
-      eq(agents.tenantId, params.scopes.tenantId),
-      eq(agents.projectId, params.scopes.projectId),
-      eq(agents.graphId, params.scopes.graphId),
-      inArray(agents.id, params.agentIds)
-    )
-  );
-};
-var getContextConfigById = (db) => async (params) => {
-  return await db.query.contextConfigs.findFirst({
-    where: and(
-      eq(contextConfigs.tenantId, params.scopes.tenantId),
-      eq(contextConfigs.projectId, params.scopes.projectId),
-      eq(contextConfigs.graphId, params.scopes.graphId),
-      eq(contextConfigs.id, params.id)
-    )
-  });
-};
-var listContextConfigs = (db) => async (params) => {
-  return await db.query.contextConfigs.findMany({
-    where: and(
-      eq(contextConfigs.tenantId, params.scopes.tenantId),
-      eq(contextConfigs.projectId, params.scopes.projectId),
-      eq(contextConfigs.graphId, params.scopes.graphId)
-    ),
-    orderBy: [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 = and(
-    eq(contextConfigs.tenantId, params.scopes.tenantId),
-    eq(contextConfigs.projectId, params.scopes.projectId),
-    eq(contextConfigs.graphId, params.scopes.graphId)
-  );
-  const [contextConfigList, totalResult] = await Promise.all([
-    db.select().from(contextConfigs).where(whereClause).limit(limit).offset(offset).orderBy(desc(contextConfigs.createdAt)),
-    db.select({ count: 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();
-  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(
-    and(
-      eq(contextConfigs.tenantId, params.scopes.tenantId),
-      eq(contextConfigs.projectId, params.scopes.projectId),
-      eq(contextConfigs.graphId, params.scopes.graphId),
-      eq(contextConfigs.id, params.id)
-    )
-  ).returning();
-  return updated[0];
-};
-var deleteContextConfig = (db) => async (params) => {
-  try {
-    const result = await db.delete(contextConfigs).where(
+    ).where(
       and(
-        eq(contextConfigs.tenantId, params.scopes.tenantId),
-        eq(contextConfigs.projectId, params.scopes.projectId),
-        eq(contextConfigs.graphId, params.scopes.graphId),
-        eq(contextConfigs.id, params.id)
+        eq(subAgentToolRelations.tenantId, params.scopes.tenantId),
+        eq(subAgentToolRelations.projectId, params.scopes.projectId),
+        eq(subAgentToolRelations.graphId, params.scopes.graphId),
+        eq(subAgentToolRelations.toolId, params.toolId)
+      )
+    ).limit(limit).offset(offset).orderBy(desc(subAgentToolRelations.createdAt)),
+    db.select({ count: count() }).from(subAgentToolRelations).where(
+      and(
+        eq(subAgentToolRelations.tenantId, params.scopes.tenantId),
+        eq(subAgentToolRelations.projectId, params.scopes.projectId),
+        eq(subAgentToolRelations.graphId, params.scopes.graphId),
+        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: count() }).from(contextConfigs).where(
-    and(
-      eq(contextConfigs.tenantId, params.scopes.tenantId),
-      eq(contextConfigs.projectId, params.scopes.projectId),
-      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(
+    and(
+      eq(subAgents.tenantId, params.scopes.tenantId),
+      eq(subAgents.projectId, params.scopes.projectId),
+      eq(subAgents.graphId, params.scopes.graphId),
+      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: and(
+var validateExternalAgent = (db) => async (params) => {
+  const result = await db.select({ id: externalAgents.id }).from(externalAgents).where(
+    and(
       eq(externalAgents.tenantId, params.scopes.tenantId),
       eq(externalAgents.projectId, params.scopes.projectId),
       eq(externalAgents.graphId, params.scopes.graphId),
-      eq(externalAgents.id, params.agentId)
+      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: and(
-      eq(externalAgents.tenantId, params.scopes.tenantId),
-      eq(externalAgents.projectId, params.scopes.projectId),
-      eq(externalAgents.graphId, params.scopes.graphId),
-      eq(externalAgents.baseUrl, params.baseUrl)
+      eq(subAgents.tenantId, params.scopes.tenantId),
+      eq(subAgents.projectId, params.scopes.projectId),
+      eq(subAgents.graphId, params.scopes.graphId),
+      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: and(
-      eq(externalAgents.tenantId, params.scopes.tenantId),
-      eq(externalAgents.projectId, params.scopes.projectId),
-      eq(externalAgents.graphId, params.scopes.graphId)
-    ),
-    orderBy: [asc(externalAgents.name)]
+      eq(subAgents.tenantId, params.scopes.tenantId),
+      eq(subAgents.projectId, params.scopes.projectId),
+      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 = and(
+    eq(subAgents.tenantId, params.scopes.tenantId),
+    eq(subAgents.projectId, params.scopes.projectId),
+    eq(subAgents.graphId, params.scopes.graphId)
+  );
   const [data, totalResult] = await Promise.all([
-    db.select().from(externalAgents).where(
-      and(
-        eq(externalAgents.tenantId, params.scopes.tenantId),
-        eq(externalAgents.projectId, params.scopes.projectId),
-        eq(externalAgents.graphId, params.scopes.graphId)
-      )
-    ).limit(limit).offset(offset).orderBy(desc(externalAgents.createdAt)),
-    db.select({ count: count() }).from(externalAgents).where(
-      and(
-        eq(externalAgents.tenantId, params.scopes.tenantId),
-        eq(externalAgents.projectId, params.scopes.projectId),
-        eq(externalAgents.graphId, params.scopes.graphId)
-      )
-    )
+    db.select().from(subAgents).where(whereClause).limit(limit).offset(offset).orderBy(desc(subAgents.createdAt)),
+    db.select({ count: 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(
     and(
-      eq(externalAgents.tenantId, params.scopes.tenantId),
-      eq(externalAgents.projectId, params.scopes.projectId),
-      eq(externalAgents.graphId, params.scopes.graphId),
-      eq(externalAgents.id, params.agentId)
+      eq(subAgents.tenantId, params.scopes.tenantId),
+      eq(subAgents.projectId, params.scopes.projectId),
+      eq(subAgents.graphId, params.scopes.graphId),
+      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(
-      and(
-        eq(externalAgents.tenantId, params.scopes.tenantId),
-        eq(externalAgents.projectId, params.scopes.projectId),
-        eq(externalAgents.graphId, params.scopes.graphId),
-        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: count() }).from(externalAgents).where(
+var deleteSubAgent = (db) => async (params) => {
+  await db.delete(subAgents).where(
     and(
-      eq(externalAgents.tenantId, params.scopes.tenantId),
-      eq(externalAgents.projectId, params.scopes.projectId),
-      eq(externalAgents.graphId, params.scopes.graphId)
+      eq(subAgents.tenantId, params.scopes.tenantId),
+      eq(subAgents.projectId, params.scopes.projectId),
+      eq(subAgents.graphId, params.scopes.graphId),
+      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(
-    and(
-      eq(functions.tenantId, tenantId),
-      eq(functions.projectId, projectId),
-      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(
-      and(
-        eq(functions.tenantId, tenantId),
-        eq(functions.projectId, projectId),
-        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(
-    and(
-      eq(functions.tenantId, tenantId),
-      eq(functions.projectId, projectId),
-      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(and(eq(functions.tenantId, tenantId), 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(
     and(
-      eq(functions.tenantId, tenantId),
-      eq(functions.projectId, projectId),
-      eq(functions.id, functionId)
+      eq(subAgents.tenantId, params.scopes.tenantId),
+      eq(subAgents.projectId, params.scopes.projectId),
+      eq(subAgents.graphId, params.scopes.graphId),
+      inArray(subAgents.id, params.subAgentIds)
     )
   );
 };
@@ -2847,12 +2848,12 @@ var deleteTool = (db) => async (params) => {
 var addToolToAgent = (db) => async (params) => {
   const id = 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,
@@ -2862,13 +2863,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(
     and(
-      eq(agentToolRelations.tenantId, params.scopes.tenantId),
-      eq(agentToolRelations.projectId, params.scopes.projectId),
-      eq(agentToolRelations.graphId, params.scopes.graphId),
-      eq(agentToolRelations.agentId, params.agentId),
-      eq(agentToolRelations.toolId, params.toolId)
+      eq(subAgentToolRelations.tenantId, params.scopes.tenantId),
+      eq(subAgentToolRelations.projectId, params.scopes.projectId),
+      eq(subAgentToolRelations.graphId, params.scopes.graphId),
+      eq(subAgentToolRelations.subAgentId, params.subAgentId),
+      eq(subAgentToolRelations.toolId, params.toolId)
     )
   ).returning();
   return deleted;
@@ -2879,7 +2880,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
@@ -2922,7 +2923,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: and(
       eq(agentGraph.tenantId, params.scopes.tenantId),
@@ -2930,7 +2931,7 @@ var getAgentGraphWithDefaultAgent = (db) => async (params) => {
       eq(agentGraph.id, params.scopes.graphId)
     ),
     with: {
-      defaultAgent: true
+      defaultSubAgent: true
     }
   });
   return result ?? null;
@@ -3035,14 +3036,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, eq(config.relationIdField, config.componentIdField)).where(
       and(
         eq(config.relationTable.tenantId, scopes.tenantId),
         eq(config.relationTable.projectId, scopes.projectId),
-        inArray(config.relationTable.agentId, agentIds)
+        inArray(config.subAgentIdField, subAgentIds)
       )
     );
     for (const component of results) {
@@ -3054,7 +3055,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)({
@@ -3064,17 +3065,17 @@ var getGraphAgentInfos = (db) => async ({
     throw new Error(`Agent graph with ID ${graphId} not found for tenant ${tenantId}`);
   }
   const relations = await getAgentRelations(db)({
-    scopes: { tenantId, projectId, graphId, agentId }
+    scopes: { tenantId, projectId, graphId, subAgentId }
   });
-  const targetAgentIds = relations.map((relation) => relation.targetAgentId).filter((id) => id !== null);
-  if (targetAgentIds.length === 0) {
+  const targetSubAgentIds = relations.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 };
@@ -3096,28 +3097,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: and(
-      eq(agents.tenantId, tenantId),
-      eq(agents.projectId, projectId),
-      eq(agents.graphId, graphId)
+      eq(subAgents.tenantId, tenantId),
+      eq(subAgents.projectId, projectId),
+      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,
@@ -3129,41 +3130,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,
         and(
-          eq(agentToolRelations.toolId, tools.id),
-          eq(agentToolRelations.tenantId, tools.tenantId),
-          eq(agentToolRelations.projectId, tools.projectId)
+          eq(subAgentToolRelations.toolId, tools.id),
+          eq(subAgentToolRelations.tenantId, tools.tenantId),
+          eq(subAgentToolRelations.projectId, tools.projectId)
         )
       ).where(
         and(
-          eq(agentToolRelations.tenantId, tenantId),
-          eq(agentToolRelations.projectId, projectId),
-          eq(agentToolRelations.graphId, graphId),
-          eq(agentToolRelations.agentId, agent.id)
+          eq(subAgentToolRelations.tenantId, tenantId),
+          eq(subAgentToolRelations.projectId, projectId),
+          eq(subAgentToolRelations.graphId, graphId),
+          eq(subAgentToolRelations.subAgentId, agent.id)
         )
       );
-      const agentDataComponentRelations = await db.query.agentDataComponents.findMany({
+      const agentDataComponentRelations = await db.query.subAgentDataComponents.findMany({
         where: and(
-          eq(agentDataComponents.tenantId, tenantId),
-          eq(agentDataComponents.agentId, agent.id)
+          eq(subAgentDataComponents.tenantId, tenantId),
+          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: and(
-          eq(agentArtifactComponents.tenantId, tenantId),
-          eq(agentArtifactComponents.agentId, agent.id)
+          eq(subAgentArtifactComponents.tenantId, tenantId),
+          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,
@@ -3185,24 +3186,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 = {};
@@ -3234,13 +3235,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,
@@ -3252,13 +3254,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,
@@ -3273,8 +3276,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()
@@ -3308,7 +3311,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;
@@ -3318,22 +3321,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(
                   and(
-                    eq(agents.tenantId, tenantId),
-                    eq(agents.projectId, projectId),
-                    eq(agents.id, agentId)
+                    eq(subAgents.tenantId, tenantId),
+                    eq(subAgents.projectId, projectId),
+                    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);
               }
             }
           }
@@ -3401,7 +3404,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,
@@ -3679,24 +3682,24 @@ var getArtifactComponentsForAgent = (db) => async (params) => {
     createdAt: artifactComponents.createdAt,
     updatedAt: artifactComponents.updatedAt
   }).from(artifactComponents).innerJoin(
-    agentArtifactComponents,
-    eq(artifactComponents.id, agentArtifactComponents.artifactComponentId)
+    subAgentArtifactComponents,
+    eq(artifactComponents.id, subAgentArtifactComponents.artifactComponentId)
   ).where(
     and(
       eq(artifactComponents.tenantId, params.scopes.tenantId),
       eq(artifactComponents.projectId, params.scopes.projectId),
-      eq(agentArtifactComponents.graphId, params.scopes.graphId),
-      eq(agentArtifactComponents.agentId, params.scopes.agentId)
+      eq(subAgentArtifactComponents.graphId, params.scopes.graphId),
+      eq(subAgentArtifactComponents.subAgentId, params.scopes.subAgentId)
     )
   ).orderBy(desc(artifactComponents.createdAt));
 };
 var associateArtifactComponentWithAgent = (db) => async (params) => {
-  const [association] = await db.insert(agentArtifactComponents).values({
+  const [association] = await db.insert(subAgentArtifactComponents).values({
     id: 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();
@@ -3704,13 +3707,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(
       and(
-        eq(agentArtifactComponents.tenantId, params.scopes.tenantId),
-        eq(agentArtifactComponents.projectId, params.scopes.projectId),
-        eq(agentArtifactComponents.graphId, params.scopes.graphId),
-        eq(agentArtifactComponents.agentId, params.scopes.agentId),
-        eq(agentArtifactComponents.artifactComponentId, params.artifactComponentId)
+        eq(subAgentArtifactComponents.tenantId, params.scopes.tenantId),
+        eq(subAgentArtifactComponents.projectId, params.scopes.projectId),
+        eq(subAgentArtifactComponents.graphId, params.scopes.graphId),
+        eq(subAgentArtifactComponents.subAgentId, params.scopes.subAgentId),
+        eq(subAgentArtifactComponents.artifactComponentId, params.artifactComponentId)
       )
     ).returning();
     return result.length > 0;
@@ -3720,60 +3723,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(
     and(
-      eq(agentArtifactComponents.tenantId, params.scopes.tenantId),
-      eq(agentArtifactComponents.graphId, params.scopes.graphId),
-      eq(agentArtifactComponents.agentId, params.scopes.agentId)
+      eq(subAgentArtifactComponents.tenantId, params.scopes.tenantId),
+      eq(subAgentArtifactComponents.graphId, params.scopes.graphId),
+      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(
     and(
-      eq(agentArtifactComponents.tenantId, params.scopes.tenantId),
-      eq(agentArtifactComponents.projectId, params.scopes.projectId),
-      eq(agentArtifactComponents.artifactComponentId, params.artifactComponentId)
+      eq(subAgentArtifactComponents.tenantId, params.scopes.tenantId),
+      eq(subAgentArtifactComponents.projectId, params.scopes.projectId),
+      eq(subAgentArtifactComponents.artifactComponentId, params.artifactComponentId)
     )
-  ).orderBy(desc(agentArtifactComponents.createdAt));
+  ).orderBy(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(
     and(
-      eq(agentArtifactComponents.tenantId, params.scopes.tenantId),
-      eq(agentArtifactComponents.projectId, params.scopes.projectId),
-      eq(agentArtifactComponents.graphId, params.scopes.graphId),
-      eq(agentArtifactComponents.agentId, params.scopes.agentId),
-      eq(agentArtifactComponents.artifactComponentId, params.artifactComponentId)
+      eq(subAgentArtifactComponents.tenantId, params.scopes.tenantId),
+      eq(subAgentArtifactComponents.projectId, params.scopes.projectId),
+      eq(subAgentArtifactComponents.graphId, params.scopes.graphId),
+      eq(subAgentArtifactComponents.subAgentId, params.scopes.subAgentId),
+      eq(subAgentArtifactComponents.artifactComponentId, params.artifactComponentId)
     )
   ).limit(1);
   return result.length > 0;
 };
 var graphHasArtifactComponents = (db) => async (params) => {
-  const result = await db.select({ count: count() }).from(agentArtifactComponents).innerJoin(
-    agents,
+  const result = await db.select({ count: count() }).from(subAgentArtifactComponents).innerJoin(
+    subAgents,
     and(
-      eq(agentArtifactComponents.agentId, agents.id),
-      eq(agentArtifactComponents.tenantId, agents.tenantId)
+      eq(subAgentArtifactComponents.subAgentId, subAgents.id),
+      eq(subAgentArtifactComponents.tenantId, subAgents.tenantId)
     )
   ).innerJoin(
-    agentRelations,
+    subAgentRelations,
     and(
-      eq(agents.id, agentRelations.sourceAgentId),
-      eq(agents.tenantId, agentRelations.tenantId),
-      eq(agents.projectId, agentRelations.projectId),
-      eq(agents.graphId, agentRelations.graphId)
+      eq(subAgents.id, subAgentRelations.sourceSubAgentId),
+      eq(subAgents.tenantId, subAgentRelations.tenantId),
+      eq(subAgents.projectId, subAgentRelations.projectId),
+      eq(subAgents.graphId, subAgentRelations.graphId)
     )
   ).where(
     and(
-      eq(agentArtifactComponents.tenantId, params.scopes.tenantId),
-      eq(agentArtifactComponents.projectId, params.scopes.projectId),
-      eq(agentRelations.graphId, params.scopes.graphId)
+      eq(subAgentArtifactComponents.tenantId, params.scopes.tenantId),
+      eq(subAgentArtifactComponents.projectId, params.scopes.projectId),
+      eq(subAgentRelations.graphId, params.scopes.graphId)
     )
   ).limit(1);
   const total = result[0]?.count || 0;
@@ -3791,12 +3794,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: count() }).from(agentArtifactComponents).where(
+  const result = await db.select({ count: count() }).from(subAgentArtifactComponents).where(
     and(
-      eq(agentArtifactComponents.tenantId, params.scopes.tenantId),
-      eq(agentArtifactComponents.projectId, params.scopes.projectId),
-      eq(agentArtifactComponents.graphId, params.scopes.graphId),
-      eq(agentArtifactComponents.agentId, params.scopes.agentId)
+      eq(subAgentArtifactComponents.tenantId, params.scopes.tenantId),
+      eq(subAgentArtifactComponents.projectId, params.scopes.projectId),
+      eq(subAgentArtifactComponents.graphId, params.scopes.graphId),
+      eq(subAgentArtifactComponents.subAgentId, params.scopes.subAgentId)
     )
   );
   const total = result[0]?.count || 0;
@@ -4031,7 +4034,7 @@ var updateConversationActiveAgent = (db) => async (params) => {
     scopes: params.scopes,
     conversationId: params.conversationId,
     data: {
-      activeAgentId: params.activeAgentId
+      activeSubAgentId: params.activeSubAgentId
     }
   });
 };
@@ -4051,12 +4054,12 @@ var createOrGetConversation = (db) => async (input) => {
       where: and(eq(conversations.tenantId, input.tenantId), 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(eq(conversations.id, input.id));
-        return { ...existing, activeAgentId: input.activeAgentId };
+        return { ...existing, activeSubAgentId: input.activeSubAgentId };
       }
       return existing;
     }
@@ -4066,7 +4069,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,
@@ -4152,13 +4155,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()
     }
   });
@@ -4166,9 +4169,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({
@@ -4268,68 +4275,71 @@ var getDataComponentsForAgent = (db) => async (params) => {
     props: dataComponents.props,
     createdAt: dataComponents.createdAt,
     updatedAt: dataComponents.updatedAt
-  }).from(dataComponents).innerJoin(agentDataComponents, eq(dataComponents.id, agentDataComponents.dataComponentId)).where(
+  }).from(dataComponents).innerJoin(
+    subAgentDataComponents,
+    eq(dataComponents.id, subAgentDataComponents.dataComponentId)
+  ).where(
     and(
       eq(dataComponents.tenantId, params.scopes.tenantId),
       eq(dataComponents.projectId, params.scopes.projectId),
-      eq(agentDataComponents.graphId, params.scopes.graphId),
-      eq(agentDataComponents.agentId, params.scopes.agentId)
+      eq(subAgentDataComponents.graphId, params.scopes.graphId),
+      eq(subAgentDataComponents.subAgentId, params.scopes.subAgentId)
     )
   ).orderBy(desc(dataComponents.createdAt));
 };
 var associateDataComponentWithAgent = (db) => async (params) => {
-  const association = await db.insert(agentDataComponents).values({
+  const association = await db.insert(subAgentDataComponents).values({
     id: 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(
     and(
-      eq(agentDataComponents.tenantId, params.scopes.tenantId),
-      eq(agentDataComponents.projectId, params.scopes.projectId),
-      eq(agentDataComponents.graphId, params.scopes.graphId),
-      eq(agentDataComponents.agentId, params.scopes.agentId),
-      eq(agentDataComponents.dataComponentId, params.dataComponentId)
+      eq(subAgentDataComponents.tenantId, params.scopes.tenantId),
+      eq(subAgentDataComponents.projectId, params.scopes.projectId),
+      eq(subAgentDataComponents.graphId, params.scopes.graphId),
+      eq(subAgentDataComponents.subAgentId, params.scopes.subAgentId),
+      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(
     and(
-      eq(agentDataComponents.tenantId, params.scopes.tenantId),
-      eq(agentDataComponents.graphId, params.scopes.graphId),
-      eq(agentDataComponents.agentId, params.scopes.agentId)
+      eq(subAgentDataComponents.tenantId, params.scopes.tenantId),
+      eq(subAgentDataComponents.graphId, params.scopes.graphId),
+      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(
     and(
-      eq(agentDataComponents.tenantId, params.scopes.tenantId),
-      eq(agentDataComponents.projectId, params.scopes.projectId),
-      eq(agentDataComponents.dataComponentId, params.dataComponentId)
+      eq(subAgentDataComponents.tenantId, params.scopes.tenantId),
+      eq(subAgentDataComponents.projectId, params.scopes.projectId),
+      eq(subAgentDataComponents.dataComponentId, params.dataComponentId)
     )
-  ).orderBy(desc(agentDataComponents.createdAt));
+  ).orderBy(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(
     and(
-      eq(agentDataComponents.tenantId, params.scopes.tenantId),
-      eq(agentDataComponents.projectId, params.scopes.projectId),
-      eq(agentDataComponents.graphId, params.scopes.graphId),
-      eq(agentDataComponents.agentId, params.scopes.agentId),
-      eq(agentDataComponents.dataComponentId, params.dataComponentId)
+      eq(subAgentDataComponents.tenantId, params.scopes.tenantId),
+      eq(subAgentDataComponents.projectId, params.scopes.projectId),
+      eq(subAgentDataComponents.graphId, params.scopes.graphId),
+      eq(subAgentDataComponents.subAgentId, params.scopes.subAgentId),
+      eq(subAgentDataComponents.dataComponentId, params.dataComponentId)
     )
   ).limit(1);
   return result.length > 0;
@@ -4426,7 +4436,7 @@ async function applyExecutionLimitsInheritance(db, logger12, 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) {
@@ -4436,7 +4446,7 @@ async function applyExecutionLimitsInheritance(db, logger12, scopes, graphData)
             agent.stopWhen.stepCountIs = projectStopWhen.stepCountIs;
             logger12.info(
               {
-                agentId,
+                subAgentId,
                 inheritedValue: projectStopWhen.stepCountIs
               },
               "Agent inherited stepCountIs from project"
@@ -4476,7 +4486,7 @@ var createFullGraphServerSide = (db, logger12 = 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
@@ -4526,7 +4536,7 @@ var createFullGraphServerSide = (db, logger12 = defaultLogger) => async (scopes,
             tenantId,
             projectId,
             name: typed.name,
-            defaultAgentId: typed.defaultAgentId,
+            defaultSubAgentId: typed.defaultSubAgentId,
             description: typed.description,
             contextConfigId,
             models: typed.models,
@@ -4555,13 +4565,13 @@ var createFullGraphServerSide = (db, logger12 = 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 {
-        logger12.info({ agentId }, "Processing internal agent");
-        await upsertAgent(db)({
+        logger12.info({ subAgentId }, "Processing internal agent");
+        await upsertSubAgent(db)({
           data: {
-            id: agentId,
+            id: subAgentId,
             tenantId,
             projectId,
             graphId: finalGraphId,
@@ -4573,24 +4583,24 @@ var createFullGraphServerSide = (db, logger12 = defaultLogger) => async (scopes,
             stopWhen: internalAgent.stopWhen
           }
         });
-        logger12.info({ agentId }, "Internal agent processed successfully");
+        logger12.info({ subAgentId }, "Internal agent processed successfully");
       } catch (error) {
-        logger12.error({ agentId, error }, "Failed to create/update internal agent");
+        logger12.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;
     logger12.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 {
-        logger12.info({ agentId }, "Processing external agent");
+        logger12.info({ subAgentId }, "Processing external agent");
         await upsertExternalAgent(db)({
           data: {
-            id: agentId,
+            id: subAgentId,
             tenantId,
             projectId,
             graphId: finalGraphId,
@@ -4601,14 +4611,14 @@ var createFullGraphServerSide = (db, logger12 = defaultLogger) => async (scopes,
             headers: externalAgent.headers || void 0
           }
         });
-        logger12.info({ agentId }, "External agent processed successfully");
+        logger12.info({ subAgentId }, "External agent processed successfully");
       } catch (error) {
-        logger12.error({ agentId, error }, "Failed to create/update external agent");
+        logger12.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;
     logger12.info({ externalAgentCount }, "All external agents created/updated successfully");
@@ -4632,26 +4642,26 @@ var createFullGraphServerSide = (db, logger12 = 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;
-                logger12.info({ agentId, toolId }, "Processing agent-tool relation");
+                logger12.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
                 });
-                logger12.info({ agentId, toolId }, "Agent-tool relation processed successfully");
+                logger12.info({ subAgentId, toolId }, "Agent-tool relation processed successfully");
               } catch (error) {
                 logger12.error(
-                  { agentId, toolId: canUseItem.toolId, error },
+                  { subAgentId, toolId: canUseItem.toolId, error },
                   "Failed to create agent-tool relation"
                 );
               }
@@ -4662,31 +4672,31 @@ var createFullGraphServerSide = (db, logger12 = defaultLogger) => async (scopes,
     }
     await Promise.all(agentToolPromises);
     logger12.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 {
                 logger12.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
                 });
                 logger12.info(
-                  { agentId, dataComponentId },
+                  { subAgentId, dataComponentId },
                   "Agent-data component relation processed successfully"
                 );
               } catch (error) {
                 logger12.error(
-                  { agentId, dataComponentId, error },
+                  { subAgentId, dataComponentId, error },
                   "Failed to create agent-data component relation"
                 );
               }
@@ -4698,27 +4708,27 @@ var createFullGraphServerSide = (db, logger12 = defaultLogger) => async (scopes,
     await Promise.all(agentDataComponentPromises);
     logger12.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 {
                 logger12.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
                 });
                 logger12.info(
-                  { agentId, artifactComponentId },
+                  { subAgentId, artifactComponentId },
                   "Agent-artifact component relation processed successfully"
                 );
               } catch (error) {
                 logger12.error(
-                  { agentId, artifactComponentId, error },
+                  { subAgentId, artifactComponentId, error },
                   "Failed to create agent-artifact component relation"
                 );
               }
@@ -4730,14 +4740,14 @@ var createFullGraphServerSide = (db, logger12 = defaultLogger) => async (scopes,
     await Promise.all(agentArtifactComponentPromises);
     logger12.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 {
                 logger12.info(
-                  { agentId, targetAgentId, type: "transfer" },
+                  { subAgentId, targetSubAgentId, type: "transfer" },
                   "Processing agent transfer relation"
                 );
                 await upsertAgentRelation(db)({
@@ -4745,17 +4755,17 @@ var createFullGraphServerSide = (db, logger12 = defaultLogger) => async (scopes,
                   tenantId,
                   projectId,
                   graphId: finalGraphId,
-                  sourceAgentId: agentId,
-                  targetAgentId,
+                  sourceSubAgentId: subAgentId,
+                  targetSubAgentId,
                   relationType: "transfer"
                 });
                 logger12.info(
-                  { agentId, targetAgentId, type: "transfer" },
+                  { subAgentId, targetSubAgentId, type: "transfer" },
                   "Agent transfer relation processed successfully"
                 );
               } catch (error) {
                 logger12.error(
-                  { agentId, targetAgentId, type: "transfer", error },
+                  { subAgentId, targetSubAgentId, type: "transfer", error },
                   "Failed to create transfer relation"
                 );
               }
@@ -4764,14 +4774,14 @@ var createFullGraphServerSide = (db, logger12 = 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 {
                 logger12.info(
-                  { agentId, targetAgentId, type: "delegate" },
+                  { subAgentId, targetSubAgentId, type: "delegate" },
                   "Processing agent delegation relation"
                 );
                 await upsertAgentRelation(db)({
@@ -4779,18 +4789,18 @@ var createFullGraphServerSide = (db, logger12 = 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"
                 });
                 logger12.info(
-                  { agentId, targetAgentId, type: "delegate" },
+                  { subAgentId, targetSubAgentId, type: "delegate" },
                   "Agent delegation relation processed successfully"
                 );
               } catch (error) {
                 logger12.error(
-                  { agentId, targetAgentId, type: "delegate", error },
+                  { subAgentId, targetSubAgentId, type: "delegate", error },
                   "Failed to create delegation relation"
                 );
               }
@@ -4828,7 +4838,7 @@ var updateFullGraphServerSide = (db, logger12 = defaultLogger) => async (scopes,
     {
       tenantId,
       graphId: typedGraphDefinition.id,
-      agentCount: Object.keys(typedGraphDefinition.agents).length
+      agentCount: Object.keys(typedGraphDefinition.subAgents).length
     },
     "Updating full graph in database"
   );
@@ -4866,7 +4876,7 @@ var updateFullGraphServerSide = (db, logger12 = 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
@@ -4924,7 +4934,7 @@ var updateFullGraphServerSide = (db, logger12 = defaultLogger) => async (scopes,
             tenantId,
             projectId,
             name: typedGraphDefinition.name,
-            defaultAgentId: typedGraphDefinition.defaultAgentId,
+            defaultSubAgentId: typedGraphDefinition.defaultSubAgentId,
             description: typedGraphDefinition.description,
             contextConfigId,
             models: typedGraphDefinition.models,
@@ -4950,15 +4960,15 @@ var updateFullGraphServerSide = (db, logger12 = 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: and(
-            eq(agents.id, agentId),
-            eq(agents.tenantId, tenantId),
-            eq(agents.projectId, projectId)
+            eq(subAgents.id, subAgentId),
+            eq(subAgents.tenantId, tenantId),
+            eq(subAgents.projectId, projectId)
           ),
           columns: {
             models: true
@@ -4979,7 +4989,7 @@ var updateFullGraphServerSide = (db, logger12 = defaultLogger) => async (scopes,
             cascadedModels[modelType] = graphModels[modelType];
             logger12.info(
               {
-                agentId,
+                subAgentId,
                 modelType,
                 oldModel: agentModels[modelType].model,
                 newModel: graphModels[modelType].model,
@@ -4992,10 +5002,10 @@ var updateFullGraphServerSide = (db, logger12 = defaultLogger) => async (scopes,
         finalModelSettings = cascadedModels;
       }
       try {
-        logger12.info({ agentId }, "Processing internal agent");
-        await upsertAgent(db)({
+        logger12.info({ subAgentId }, "Processing internal agent");
+        await upsertSubAgent(db)({
           data: {
-            id: agentId,
+            id: subAgentId,
             tenantId,
             projectId,
             graphId: finalGraphId,
@@ -5007,24 +5017,24 @@ var updateFullGraphServerSide = (db, logger12 = defaultLogger) => async (scopes,
             stopWhen: internalAgent.stopWhen
           }
         });
-        logger12.info({ agentId }, "Internal agent processed successfully");
+        logger12.info({ subAgentId }, "Internal agent processed successfully");
       } catch (error) {
-        logger12.error({ agentId, error }, "Failed to create/update internal agent");
+        logger12.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;
     logger12.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 {
-        logger12.info({ agentId }, "Processing external agent");
+        logger12.info({ subAgentId }, "Processing external agent");
         await upsertExternalAgent(db)({
           data: {
-            id: agentId,
+            id: subAgentId,
             tenantId,
             projectId,
             graphId: finalGraphId,
@@ -5035,19 +5045,19 @@ var updateFullGraphServerSide = (db, logger12 = defaultLogger) => async (scopes,
             headers: externalAgent.headers || void 0
           }
         });
-        logger12.info({ agentId }, "External agent processed successfully");
+        logger12.info({ subAgentId }, "External agent processed successfully");
       } catch (error) {
-        logger12.error({ agentId, error }, "Failed to create/update external agent");
+        logger12.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;
     logger12.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)({
@@ -5057,14 +5067,17 @@ var updateFullGraphServerSide = (db, logger12 = 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++;
-          logger12.info({ agentId: agent.id }, "Deleted orphaned internal agent");
+          logger12.info({ subAgentId: agent.id }, "Deleted orphaned internal agent");
         } catch (error) {
-          logger12.error({ agentId: agent.id, error }, "Failed to delete orphaned internal agent");
+          logger12.error(
+            { subAgentId: agent.id, error },
+            "Failed to delete orphaned internal agent"
+          );
         }
       }
     }
@@ -5074,12 +5087,15 @@ var updateFullGraphServerSide = (db, logger12 = defaultLogger) => async (scopes,
         try {
           await deleteExternalAgent(db)({
             scopes: { tenantId, projectId, graphId: finalGraphId },
-            agentId: agent.id
+            subAgentId: agent.id
           });
           deletedExternalCount++;
-          logger12.info({ agentId: agent.id }, "Deleted orphaned external agent");
+          logger12.info({ subAgentId: agent.id }, "Deleted orphaned external agent");
         } catch (error) {
-          logger12.error({ agentId: agent.id, error }, "Failed to delete orphaned external agent");
+          logger12.error(
+            { subAgentId: agent.id, error },
+            "Failed to delete orphaned external agent"
+          );
         }
       }
     }
@@ -5097,7 +5113,7 @@ var updateFullGraphServerSide = (db, logger12 = 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,
@@ -5108,7 +5124,7 @@ var updateFullGraphServerSide = (db, logger12 = defaultLogger) => async (scopes,
     });
     logger12.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) {
@@ -5117,63 +5133,63 @@ var updateFullGraphServerSide = (db, logger12 = 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(
             and(
-              eq(agentToolRelations.tenantId, tenantId),
-              eq(agentToolRelations.projectId, projectId),
-              eq(agentToolRelations.graphId, finalGraphId),
-              eq(agentToolRelations.agentId, agentId)
+              eq(subAgentToolRelations.tenantId, tenantId),
+              eq(subAgentToolRelations.projectId, projectId),
+              eq(subAgentToolRelations.graphId, finalGraphId),
+              eq(subAgentToolRelations.subAgentId, subAgentId)
             )
           );
           deletedCount = result.rowsAffected || 0;
         } else {
-          const result = await db.delete(agentToolRelations).where(
+          const result = await db.delete(subAgentToolRelations).where(
             and(
-              eq(agentToolRelations.tenantId, tenantId),
-              eq(agentToolRelations.projectId, projectId),
-              eq(agentToolRelations.graphId, finalGraphId),
-              eq(agentToolRelations.agentId, agentId),
-              not(inArray(agentToolRelations.id, Array.from(incomingRelationshipIds)))
+              eq(subAgentToolRelations.tenantId, tenantId),
+              eq(subAgentToolRelations.projectId, projectId),
+              eq(subAgentToolRelations.graphId, finalGraphId),
+              eq(subAgentToolRelations.subAgentId, subAgentId),
+              not(inArray(subAgentToolRelations.id, Array.from(incomingRelationshipIds)))
             )
           );
           deletedCount = result.rowsAffected || 0;
         }
         if (deletedCount > 0) {
-          logger12.info({ agentId, deletedCount }, "Deleted orphaned agent-tool relations");
+          logger12.info({ subAgentId, deletedCount }, "Deleted orphaned agent-tool relations");
         }
       } catch (error) {
-        logger12.error({ agentId, error }, "Failed to delete orphaned agent-tool relations");
+        logger12.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;
-                logger12.info({ agentId, toolId }, "Processing agent-tool relation");
+                logger12.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
                 });
                 logger12.info(
-                  { agentId, toolId, relationId: agentToolRelationId },
+                  { subAgentId, toolId, relationId: agentToolRelationId },
                   "Agent-tool relation upserted"
                 );
               } catch (error) {
                 logger12.error(
                   {
-                    agentId,
+                    subAgentId,
                     toolId: canUseItem.toolId,
                     relationId: canUseItem.agentToolRelationId,
                     error
@@ -5191,26 +5207,29 @@ var updateFullGraphServerSide = (db, logger12 = 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
                 });
-                logger12.info({ agentId, dataComponentId }, "Agent-dataComponent relation created");
+                logger12.info(
+                  { subAgentId, dataComponentId },
+                  "Agent-dataComponent relation created"
+                );
               } catch (error) {
                 logger12.error(
-                  { agentId, dataComponentId, error },
+                  { subAgentId, dataComponentId, error },
                   "Failed to create agent-dataComponent relation"
                 );
               }
@@ -5224,29 +5243,29 @@ var updateFullGraphServerSide = (db, logger12 = 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
                 });
                 logger12.info(
-                  { agentId, artifactComponentId },
+                  { subAgentId, artifactComponentId },
                   "Agent-artifactComponent relation created"
                 );
               } catch (error) {
                 logger12.error(
-                  { agentId, artifactComponentId, error },
+                  { subAgentId, artifactComponentId, error },
                   "Failed to create agent-artifactComponent relation"
                 );
               }
@@ -5264,34 +5283,34 @@ var updateFullGraphServerSide = (db, logger12 = 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(),
                   graphId: typedGraphDefinition.id || "",
-                  sourceAgentId: agentId,
+                  sourceSubAgentId: subAgentId,
                   relationType: "transfer",
-                  [targetField]: targetAgentId
+                  [targetField]: targetSubAgentId
                 };
-                await createAgentRelation(db)({
+                await createSubAgentRelation(db)({
                   tenantId,
                   projectId,
                   ...relationData
                 });
                 logger12.info(
-                  { agentId, targetAgentId, isTargetExternal },
+                  { subAgentId, targetSubAgentId, isTargetExternal },
                   "Transfer relation created"
                 );
               } catch (error) {
                 logger12.error(
-                  { agentId, targetAgentId, error },
+                  { subAgentId, targetSubAgentId, error },
                   "Failed to create transfer relation"
                 );
               }
@@ -5300,29 +5319,29 @@ var updateFullGraphServerSide = (db, logger12 = 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(),
                   graphId: typedGraphDefinition.id || "",
-                  sourceAgentId: agentId,
+                  sourceSubAgentId: subAgentId,
                   relationType: "delegate",
-                  [targetField]: targetAgentId
+                  [targetField]: targetSubAgentId
                 };
-                await createAgentRelation(db)({
+                await createSubAgentRelation(db)({
                   tenantId,
                   projectId,
                   ...relationData
                 });
-                logger12.info({ agentId, targetAgentId }, "Delegation relation created");
+                logger12.info({ subAgentId, targetSubAgentId }, "Delegation relation created");
               } catch (error) {
                 logger12.error(
-                  { agentId, targetAgentId, error },
+                  { subAgentId, targetSubAgentId, error },
                   "Failed to create delegation relation"
                 );
               }
@@ -5365,7 +5384,7 @@ var getFullGraph = (db, logger12 = defaultLogger) => async (params) => {
       {
         tenantId,
         graphId: scopes.graphId,
-        agentCount: Object.keys(graph.agents).length
+        agentCount: Object.keys(graph.subAgents).length
       },
       "Full graph retrieved successfully"
     );
@@ -5397,15 +5416,15 @@ var deleteFullGraph = (db, logger12 = defaultLogger) => async (params) => {
       scopes: { tenantId, projectId, graphId }
     });
     logger12.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 }
         });
       }
       logger12.info(
-        { tenantId, graphId, agentCount: agentIds.length },
+        { tenantId, graphId, agentCount: subAgentIds.length },
         "Agent-tool relations deleted"
       );
     }
@@ -5804,15 +5823,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(eq(agents.tenantId, params.tenantId)),
+    db.selectDistinct({ projectId: subAgents.projectId }).from(subAgents).where(eq(subAgents.tenantId, params.tenantId)),
     db.selectDistinct({ projectId: agentGraph.projectId }).from(agentGraph).where(eq(agentGraph.tenantId, params.tenantId)),
     db.selectDistinct({ projectId: tools.projectId }).from(tools).where(eq(tools.tenantId, params.tenantId)),
     db.selectDistinct({ projectId: contextConfigs.projectId }).from(contextConfigs).where(eq(contextConfigs.tenantId, params.tenantId)),
     db.selectDistinct({ projectId: externalAgents.projectId }).from(externalAgents).where(eq(externalAgents.tenantId, params.tenantId)),
-    db.selectDistinct({ projectId: agentRelations.projectId }).from(agentRelations).where(eq(agentRelations.tenantId, params.tenantId)),
-    db.selectDistinct({ projectId: agentToolRelations.projectId }).from(agentToolRelations).where(eq(agentToolRelations.tenantId, params.tenantId)),
-    db.selectDistinct({ projectId: agentDataComponents.projectId }).from(agentDataComponents).where(eq(agentDataComponents.tenantId, params.tenantId)),
-    db.selectDistinct({ projectId: agentArtifactComponents.projectId }).from(agentArtifactComponents).where(eq(agentArtifactComponents.tenantId, params.tenantId)),
+    db.selectDistinct({ projectId: subAgentRelations.projectId }).from(subAgentRelations).where(eq(subAgentRelations.tenantId, params.tenantId)),
+    db.selectDistinct({ projectId: subAgentToolRelations.projectId }).from(subAgentToolRelations).where(eq(subAgentToolRelations.tenantId, params.tenantId)),
+    db.selectDistinct({ projectId: subAgentDataComponents.projectId }).from(subAgentDataComponents).where(eq(subAgentDataComponents.tenantId, params.tenantId)),
+    db.selectDistinct({ projectId: subAgentArtifactComponents.projectId }).from(subAgentArtifactComponents).where(eq(subAgentArtifactComponents.tenantId, params.tenantId)),
     db.selectDistinct({ projectId: dataComponents.projectId }).from(dataComponents).where(eq(dataComponents.tenantId, params.tenantId)),
     db.selectDistinct({ projectId: artifactComponents.projectId }).from(artifactComponents).where(eq(artifactComponents.tenantId, params.tenantId)),
     db.selectDistinct({ projectId: tasks.projectId }).from(tasks).where(eq(tasks.tenantId, params.tenantId)),
@@ -5852,7 +5871,7 @@ var listProjectsPaginated = (db) => async (params) => {
 var getProjectResourceCounts = (db) => async (params) => {
   const whereClause = (table) => and(eq(table.tenantId, params.tenantId), 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)),
@@ -5869,7 +5888,7 @@ var getProjectResourceCounts = (db) => async (params) => {
 var projectExists = (db) => async (params) => {
   const whereClause = (table) => and(eq(table.tenantId, params.tenantId), 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),
@@ -5976,8 +5995,8 @@ async function cascadeStopWhenUpdates(db, scopes, oldStopWhen, newStopWhen) {
     }
   }
   if (oldStopWhen?.stepCountIs !== newStopWhen?.stepCountIs) {
-    const agentsToUpdate = await db.query.agents.findMany({
-      where: and(eq(agents.tenantId, tenantId), eq(agents.projectId, projectId))
+    const agentsToUpdate = await db.query.subAgents.findMany({
+      where: and(eq(subAgents.tenantId, tenantId), eq(subAgents.projectId, projectId))
     });
     for (const agent of agentsToUpdate) {
       const agentStopWhen = agent.stopWhen;
@@ -5986,14 +6005,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(
           and(
-            eq(agents.tenantId, tenantId),
-            eq(agents.projectId, projectId),
-            eq(agents.id, agent.id)
+            eq(subAgents.tenantId, tenantId),
+            eq(subAgents.projectId, projectId),
+            eq(subAgents.id, agent.id)
           )
         );
       }
@@ -6245,6 +6264,10 @@ var createFullProjectServerSide = (db, logger12 = defaultLogger2) => async (scop
           logger12.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 || {},
@@ -6584,6 +6607,10 @@ var updateFullProjectServerSide = (db, logger12 = defaultLogger2) => async (scop
           logger12.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 || {},
@@ -7687,7 +7714,7 @@ async function validateHeaders({
   credentialStores
 }) {
   try {
-    const agentGraph2 = await getAgentGraphWithDefaultAgent(dbClient)({
+    const agentGraph2 = await getAgentGraphWithDefaultSubAgent(dbClient)({
       scopes: { tenantId, projectId, graphId }
     });
     if (!agentGraph2?.contextConfigId) {
@@ -8250,7 +8277,7 @@ async function handleContextResolution({
       let agentGraph2;
       let trigger;
       try {
-        agentGraph2 = await getAgentGraphWithDefaultAgent(dbClient)({
+        agentGraph2 = await getAgentGraphWithDefaultSubAgent(dbClient)({
           scopes: { tenantId, projectId, graphId }
         });
         if (!agentGraph2?.contextConfigId) {
@@ -9179,4 +9206,4 @@ ${error.message}`
 };
 parseEnv();
 
-export { ContextCache, ContextConfigBuilder, ContextFetcher, ContextResolver, CredentialStoreRegistry, CredentialStuffer, ERROR_DOCS_BASE_URL, ErrorCode, HTTP_REQUEST_PARTS, InMemoryCredentialStore, KeyChainStore, McpClient, NangoCredentialStore, TemplateEngine, addLedgerArtifacts, addToolToAgent, apiFetch, associateArtifactComponentWithAgent, associateDataComponentWithAgent, cleanupTenantCache, clearContextConfigCache, clearConversationCache, commonCreateErrorResponses, commonDeleteErrorResponses, commonGetErrorResponses, commonUpdateErrorResponses, contextConfig, contextValidationMiddleware, countApiKeys, countArtifactComponents, countArtifactComponentsForAgent, countContextConfigs, countCredentialReferences, countDataComponents, countExternalAgents, countLedgerArtifactsByTask, countMessagesByConversation, countProjects, createAgent, createAgentGraph, createAgentRelation, createAgentToolRelation, createApiError, createApiKey, createArtifactComponent, createContextConfig, createConversation, createCredentialReference, createDataComponent, createDatabaseClient, createDefaultCredentialStores, createExecutionContext, createExternalAgent, createExternalAgentRelation, createFullGraphServerSide, createFullProjectServerSide, createInMemoryDatabaseClient, createKeyChainStore, createMessage, createNangoCredentialStore, createOrGetConversation, createProject, createTask, createTool, createValidatedDataAccess, dbResultToMcpTool, deleteAgent, deleteAgentArtifactComponentRelationByAgent, deleteAgentDataComponentRelationByAgent, deleteAgentGraph, deleteAgentRelation, deleteAgentRelationsByGraph, deleteAgentToolRelation, deleteAgentToolRelationByAgent, deleteApiKey, deleteArtifactComponent, deleteContextConfig, deleteConversation, deleteCredentialReference, deleteDataComponent, deleteExternalAgent, deleteFullGraph, deleteFullProject, deleteFunction, deleteLedgerArtifactsByContext, deleteLedgerArtifactsByTask, deleteMessage, deleteProject, deleteTool, detectAuthenticationRequired, determineContextTrigger, discoverOAuthEndpoints, errorResponseSchema, errorSchemaFactory, externalAgentExists, externalAgentUrlExists, extractPublicId, fetchComponentRelationships, fetchDefinition, generateAndCreateApiKey, generateApiKey, generateId, getActiveAgentForConversation, getAgentById, getAgentGraphById, getAgentGraphWithDefaultAgent, getAgentRelationById, getAgentRelationByParams, getAgentRelations, getAgentRelationsByGraph, getAgentRelationsBySource, getAgentRelationsByTarget, getAgentToolRelationByAgent, getAgentToolRelationById, getAgentToolRelationByTool, getAgentsByIds, getAgentsForTool, getAgentsUsingArtifactComponent, getAgentsUsingDataComponent, getApiKeyById, getApiKeyByPublicId, getArtifactComponentById, getArtifactComponentsForAgent, getCacheEntry, getCachedValidator, getContextConfigById, getContextConfigCacheEntries, getConversation, getConversationCacheEntries, getConversationHistory, getConversationId, getCredentialReference, getCredentialReferenceById, getCredentialReferenceWithTools, getCredentialStoreLookupKeyFromRetrievalParams, getDataComponent, getDataComponentsForAgent, getExternalAgent, getExternalAgentByUrl, getExternalAgentRelations, getFullGraph, getFullGraphDefinition, getFullProject, getFunction, getGraphAgentInfos, getLedgerArtifacts, getLedgerArtifactsByContext, getMessageById, getMessagesByConversation, getMessagesByTask, getProject, getProjectResourceCounts, getRelatedAgentsForGraph, getRequestExecutionContext, getTask, getToolById, getToolsForAgent, getTracer, getVisibleMessages, graphHasArtifactComponents, handleApiError, handleContextConfigChange, handleContextResolution, hasApiKey, hasContextConfig, hasCredentialReference, hashApiKey, headers, invalidateHeadersCache, invalidateInvocationDefinitionsCache, isApiKeyExpired, isArtifactComponentAssociatedWithAgent, isDataComponentAssociatedWithAgent, isValidHttpRequest, listAgentGraphs, listAgentGraphsPaginated, listAgentRelations, listAgentToolRelations, listAgents, listAgentsPaginated, listApiKeys, listApiKeysPaginated, listArtifactComponents, listArtifactComponentsPaginated, listContextConfigs, listContextConfigsPaginated, listConversations, listCredentialReferences, listCredentialReferencesPaginated, listDataComponents, listDataComponentsPaginated, listExternalAgents, listExternalAgentsPaginated, listFunctions, listMessages, listProjects, listProjectsPaginated, listTaskIdsByContextId, listTools, loadEnvironmentFiles, maskApiKey, problemDetailsSchema, projectExists, projectExistsInTable, projectHasResources, removeArtifactComponentFromAgent, removeDataComponentFromAgent, removeToolFromAgent, setActiveAgentForConversation, setActiveAgentForThread, setCacheEntry, setSpanWithError, updateAgent, updateAgentGraph, updateAgentRelation, updateAgentToolRelation, updateApiKey, updateApiKeyLastUsed, updateArtifactComponent, updateContextConfig, updateConversation, updateConversationActiveAgent, updateCredentialReference, updateDataComponent, updateExternalAgent, updateFullGraphServerSide, updateFullProjectServerSide, updateMessage, updateProject, updateTask, updateTool, upsertAgent, upsertAgentArtifactComponentRelation, upsertAgentDataComponentRelation, upsertAgentGraph, upsertAgentRelation, upsertAgentToolRelation, upsertArtifactComponent, upsertContextConfig, upsertCredentialReference, upsertDataComponent, upsertExternalAgent, upsertFunction, upsertLedgerArtifact, upsertTool, validateAgainstJsonSchema, validateAndGetApiKey, validateApiKey, validateExternalAgent, validateHeaders, validateHttpRequestHeaders, validateInternalAgent, validateProjectExists, validationHelper, withProjectValidation };
+export { ContextCache, ContextConfigBuilder, ContextFetcher, ContextResolver, CredentialStoreRegistry, CredentialStuffer, ERROR_DOCS_BASE_URL, ErrorCode, HTTP_REQUEST_PARTS, InMemoryCredentialStore, KeyChainStore, McpClient, NangoCredentialStore, TemplateEngine, addLedgerArtifacts, addToolToAgent, apiFetch, associateArtifactComponentWithAgent, associateDataComponentWithAgent, cleanupTenantCache, clearContextConfigCache, clearConversationCache, commonCreateErrorResponses, commonDeleteErrorResponses, commonGetErrorResponses, commonUpdateErrorResponses, contextConfig, contextValidationMiddleware, countApiKeys, countArtifactComponents, countArtifactComponentsForAgent, countContextConfigs, countCredentialReferences, countDataComponents, countExternalAgents, countLedgerArtifactsByTask, countMessagesByConversation, countProjects, createAgentGraph, createAgentToolRelation, createApiError, createApiKey, createArtifactComponent, createContextConfig, createConversation, createCredentialReference, createDataComponent, createDatabaseClient, createDefaultCredentialStores, createExecutionContext, createExternalAgent, createExternalAgentRelation, createFullGraphServerSide, createFullProjectServerSide, createInMemoryDatabaseClient, createKeyChainStore, createMessage, createNangoCredentialStore, createOrGetConversation, createProject, createSubAgent, createSubAgentRelation, createTask, createTool, createValidatedDataAccess, dbResultToMcpTool, deleteAgentArtifactComponentRelationByAgent, deleteAgentDataComponentRelationByAgent, deleteAgentGraph, deleteAgentRelationsByGraph, deleteAgentToolRelation, deleteAgentToolRelationByAgent, deleteApiKey, deleteArtifactComponent, deleteContextConfig, deleteConversation, deleteCredentialReference, deleteDataComponent, deleteExternalAgent, deleteFullGraph, deleteFullProject, deleteFunction, deleteLedgerArtifactsByContext, deleteLedgerArtifactsByTask, deleteMessage, deleteProject, deleteSubAgent, deleteSubAgentRelation, deleteTool, detectAuthenticationRequired, determineContextTrigger, discoverOAuthEndpoints, errorResponseSchema, errorSchemaFactory, externalAgentExists, externalAgentUrlExists, extractPublicId, fetchComponentRelationships, fetchDefinition, generateAndCreateApiKey, generateApiKey, generateId, getActiveAgentForConversation, getAgentGraphById, getAgentGraphWithDefaultSubAgent, getAgentRelationById, getAgentRelationByParams, getAgentRelations, getAgentRelationsByGraph, getAgentRelationsBySource, getAgentRelationsByTarget, getAgentToolRelationByAgent, getAgentToolRelationById, getAgentToolRelationByTool, getAgentsForTool, getAgentsUsingArtifactComponent, getAgentsUsingDataComponent, getApiKeyById, getApiKeyByPublicId, getArtifactComponentById, getArtifactComponentsForAgent, getCacheEntry, getCachedValidator, getContextConfigById, getContextConfigCacheEntries, getConversation, getConversationCacheEntries, getConversationHistory, getConversationId, getCredentialReference, getCredentialReferenceById, getCredentialReferenceWithTools, getCredentialStoreLookupKeyFromRetrievalParams, getDataComponent, getDataComponentsForAgent, getExternalAgent, getExternalAgentByUrl, getExternalAgentRelations, getFullGraph, getFullGraphDefinition, getFullProject, getFunction, getGraphAgentInfos, getLedgerArtifacts, getLedgerArtifactsByContext, getMessageById, getMessagesByConversation, getMessagesByTask, getProject, getProjectResourceCounts, getRelatedAgentsForGraph, getRequestExecutionContext, getSubAgentById, getSubAgentsByIds, getTask, getToolById, getToolsForAgent, getTracer, getVisibleMessages, graphHasArtifactComponents, handleApiError, handleContextConfigChange, handleContextResolution, hasApiKey, hasContextConfig, hasCredentialReference, hashApiKey, headers, invalidateHeadersCache, invalidateInvocationDefinitionsCache, isApiKeyExpired, isArtifactComponentAssociatedWithAgent, isDataComponentAssociatedWithAgent, isValidHttpRequest, listAgentGraphs, listAgentGraphsPaginated, listAgentRelations, listAgentToolRelations, listApiKeys, listApiKeysPaginated, listArtifactComponents, listArtifactComponentsPaginated, listContextConfigs, listContextConfigsPaginated, listConversations, listCredentialReferences, listCredentialReferencesPaginated, listDataComponents, listDataComponentsPaginated, listExternalAgents, listExternalAgentsPaginated, listFunctions, listMessages, listProjects, listProjectsPaginated, listSubAgents, listSubAgentsPaginated, listTaskIdsByContextId, listTools, loadEnvironmentFiles, maskApiKey, problemDetailsSchema, projectExists, projectExistsInTable, projectHasResources, removeArtifactComponentFromAgent, removeDataComponentFromAgent, removeToolFromAgent, setActiveAgentForConversation, setActiveAgentForThread, setCacheEntry, setSpanWithError, updateAgentGraph, updateAgentRelation, updateAgentToolRelation, updateApiKey, updateApiKeyLastUsed, updateArtifactComponent, updateContextConfig, updateConversation, updateConversationActiveAgent, updateCredentialReference, updateDataComponent, updateExternalAgent, updateFullGraphServerSide, updateFullProjectServerSide, updateMessage, updateProject, updateSubAgent, updateTask, updateTool, upsertAgentArtifactComponentRelation, upsertAgentDataComponentRelation, upsertAgentGraph, upsertAgentRelation, upsertAgentToolRelation, upsertArtifactComponent, upsertContextConfig, upsertCredentialReference, upsertDataComponent, upsertExternalAgent, upsertFunction, upsertLedgerArtifact, upsertSubAgent, upsertTool, validateAgainstJsonSchema, validateAndGetApiKey, validateApiKey, validateExternalAgent, validateHeaders, validateHttpRequestHeaders, validateInternalSubAgent, validateProjectExists, validationHelper, withProjectValidation };