@inkeep/agents-core 0.0.0-dev-20251012022558 → 0.0.0-dev-20251012045242

package/dist/index.js

@@ -1,14 +1,14 @@
-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, TRANSFER_FROM_SUB_AGENT_ID, TRANSFER_TO_SUB_AGENT_ID, UNKNOWN_VALUE } from './chunk-H6PMWHNV.js';
+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, TRANSFER_FROM_SUB_AGENT_ID, TRANSFER_TO_SUB_AGENT_ID, UNKNOWN_VALUE } from './chunk-SLL6V3AE.js';
 export { ANTHROPIC_MODELS, GOOGLE_MODELS, OPENAI_MODELS } from './chunk-HYS7HUYJ.js';
 export { TaskState } from './chunk-H2F72PDA.js';
 import { getLogger, convertZodToJsonSchema } from './chunk-YECQCT5N.js';
 export { PinoLogger, convertZodToJsonSchema, convertZodToJsonSchemaWithPreview, extractPreviewFields, getLogger, isZodSchema, loggerFactory, preview } from './chunk-YECQCT5N.js';
-import { validateAndTypeGraphData, validateGraphStructure, isInternalAgent, isExternalAgent } from './chunk-JK3LPVOW.js';
-export { A2AMessageMetadataSchema, DataOperationDetailsSchema, DataOperationEventSchema, DelegationReturnedDataSchema, DelegationSentDataSchema, TransferDataSchema, generateIdFromName, isExternalAgent, isInternalAgent, isValidResourceId, validateAgentRelationships, validateAndTypeGraphData, validateArtifactComponentReferences, validateDataComponentReferences, validateGraphStructure, validateToolReferences } from './chunk-JK3LPVOW.js';
-import { ContextConfigApiUpdateSchema, validatePropsAsJsonSchema } from './chunk-ASA7FU3H.js';
-export { AgentGraphApiInsertSchema, AgentGraphApiSelectSchema, AgentGraphApiUpdateSchema, AgentGraphInsertSchema, AgentGraphSelectSchema, AgentGraphUpdateSchema, 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, ExternalAgentSelectSchema, ExternalAgentUpdateSchema, ExternalSubAgentRelationApiInsertSchema, ExternalSubAgentRelationInsertSchema, FetchConfigSchema, FetchDefinitionSchema, FullGraphAgentInsertSchema, FullGraphDefinitionSchema, FullProjectDefinitionSchema, FunctionApiInsertSchema, FunctionApiSelectSchema, FunctionApiUpdateSchema, FunctionInsertSchema, FunctionSelectSchema, FunctionToolApiInsertSchema, FunctionToolApiSelectSchema, FunctionToolApiUpdateSchema, FunctionToolConfigSchema, FunctionToolInsertSchema, FunctionToolSelectSchema, FunctionToolUpdateSchema, 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, SubAgentArtifactComponentApiInsertSchema, SubAgentArtifactComponentApiSelectSchema, SubAgentArtifactComponentApiUpdateSchema, SubAgentArtifactComponentInsertSchema, SubAgentArtifactComponentSelectSchema, SubAgentArtifactComponentUpdateSchema, SubAgentDataComponentApiInsertSchema, SubAgentDataComponentApiSelectSchema, SubAgentDataComponentApiUpdateSchema, SubAgentDataComponentInsertSchema, SubAgentDataComponentSelectSchema, SubAgentDataComponentUpdateSchema, SubAgentInsertSchema, SubAgentRelationApiInsertSchema, SubAgentRelationApiSelectSchema, SubAgentRelationApiUpdateSchema, SubAgentRelationInsertSchema, SubAgentRelationQuerySchema, SubAgentRelationSelectSchema, SubAgentRelationUpdateSchema, SubAgentSelectSchema, SubAgentStopWhenSchema, SubAgentToolRelationApiInsertSchema, SubAgentToolRelationApiSelectSchema, SubAgentToolRelationApiUpdateSchema, SubAgentToolRelationInsertSchema, SubAgentToolRelationSelectSchema, SubAgentToolRelationUpdateSchema, 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-ASA7FU3H.js';
-import { schema_exports, contextConfigs, externalAgents, functions, functionTools, agentFunctionToolRelations, subAgentRelations, subAgents, subAgentToolRelations, tools, credentialReferences, agentGraph, subAgentDataComponents, subAgentArtifactComponents, dataComponents, artifactComponents, projects, apiKeys, contextCache, conversations, messages, ledgerArtifacts, tasks, taskRelations } from './chunk-OEKS3RQI.js';
-export { agentFunctionToolRelations, agentFunctionToolRelationsRelations, agentGraph, agentGraphRelations, agentToolRelationsRelations, apiKeys, apiKeysRelations, artifactComponents, artifactComponentsRelations, contextCache, contextCacheRelations, contextConfigs, contextConfigsRelations, conversations, conversationsRelations, credentialReferences, credentialReferencesRelations, dataComponents, dataComponentsRelations, externalAgents, externalAgentsRelations, functionTools, functionToolsRelations, 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-OEKS3RQI.js';
+import { validateAndTypeAgentData, validateAgentStructure, isInternalAgent, isExternalAgent } from './chunk-3XUV5Q4D.js';
+export { A2AMessageMetadataSchema, DataOperationDetailsSchema, DataOperationEventSchema, DelegationReturnedDataSchema, DelegationSentDataSchema, TransferDataSchema, generateIdFromName, isExternalAgent, isInternalAgent, isValidResourceId, validateAgentRelationships, validateAgentStructure, validateAndTypeAgentData, validateArtifactComponentReferences, validateDataComponentReferences, validateToolReferences } from './chunk-3XUV5Q4D.js';
+import { ContextConfigApiUpdateSchema, validatePropsAsJsonSchema } from './chunk-3GZBRBXP.js';
+export { AgentApiInsertSchema, AgentApiSelectSchema, AgentApiUpdateSchema, AgentInsertSchema, AgentSelectSchema, AgentStopWhenSchema, AgentUpdateSchema, AgentWithinContextOfProjectSchema, 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, ExternalAgentSelectSchema, ExternalAgentUpdateSchema, ExternalSubAgentRelationApiInsertSchema, ExternalSubAgentRelationInsertSchema, FetchConfigSchema, FetchDefinitionSchema, FullAgentAgentInsertSchema, FullProjectDefinitionSchema, FunctionApiInsertSchema, FunctionApiSelectSchema, FunctionApiUpdateSchema, FunctionInsertSchema, FunctionSelectSchema, FunctionToolApiInsertSchema, FunctionToolApiSelectSchema, FunctionToolApiUpdateSchema, FunctionToolConfigSchema, FunctionToolInsertSchema, FunctionToolSelectSchema, FunctionToolUpdateSchema, FunctionUpdateSchema, 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, SubAgentArtifactComponentApiInsertSchema, SubAgentArtifactComponentApiSelectSchema, SubAgentArtifactComponentApiUpdateSchema, SubAgentArtifactComponentInsertSchema, SubAgentArtifactComponentSelectSchema, SubAgentArtifactComponentUpdateSchema, SubAgentDataComponentApiInsertSchema, SubAgentDataComponentApiSelectSchema, SubAgentDataComponentApiUpdateSchema, SubAgentDataComponentInsertSchema, SubAgentDataComponentSelectSchema, SubAgentDataComponentUpdateSchema, SubAgentInsertSchema, SubAgentRelationApiInsertSchema, SubAgentRelationApiSelectSchema, SubAgentRelationApiUpdateSchema, SubAgentRelationInsertSchema, SubAgentRelationQuerySchema, SubAgentRelationSelectSchema, SubAgentRelationUpdateSchema, SubAgentSelectSchema, SubAgentStopWhenSchema, SubAgentToolRelationApiInsertSchema, SubAgentToolRelationApiSelectSchema, SubAgentToolRelationApiUpdateSchema, SubAgentToolRelationInsertSchema, SubAgentToolRelationSelectSchema, SubAgentToolRelationUpdateSchema, SubAgentUpdateSchema, TaskApiInsertSchema, TaskApiSelectSchema, TaskApiUpdateSchema, TaskInsertSchema, TaskRelationApiInsertSchema, TaskRelationApiSelectSchema, TaskRelationApiUpdateSchema, TaskRelationInsertSchema, TaskRelationSelectSchema, TaskRelationUpdateSchema, TaskSelectSchema, TaskUpdateSchema, TenantIdParamsSchema, TenantParamsSchema, TenantProjectAgentIdParamsSchema, TenantProjectAgentParamsSchema, TenantProjectAgentSubAgentIdParamsSchema, TenantProjectAgentSubAgentParamsSchema, TenantProjectIdParamsSchema, TenantProjectParamsSchema, ToolApiInsertSchema, ToolApiSelectSchema, ToolApiUpdateSchema, ToolInsertSchema, ToolSelectSchema, ToolStatusSchema, ToolUpdateSchema, URL_SAFE_ID_PATTERN, resourceIdSchema, validatePropsAsJsonSchema } from './chunk-3GZBRBXP.js';
+import { schema_exports, contextConfigs, externalAgents, functions, functionTools, agentFunctionToolRelations, subAgentRelations, subAgents, subAgentToolRelations, tools, credentialReferences, agents, subAgentDataComponents, subAgentArtifactComponents, dataComponents, artifactComponents, projects, apiKeys, contextCache, conversations, messages, ledgerArtifacts, tasks, taskRelations } from './chunk-B6F3RF4T.js';
+export { agentFunctionToolRelations, agentFunctionToolRelationsRelations, agentRelations, agentToolRelationsRelations, agents, apiKeys, apiKeysRelations, artifactComponents, artifactComponentsRelations, contextCache, contextCacheRelations, contextConfigs, contextConfigsRelations, conversations, conversationsRelations, credentialReferences, credentialReferencesRelations, dataComponents, dataComponentsRelations, externalAgents, externalAgentsRelations, functionTools, functionToolsRelations, 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-B6F3RF4T.js';
 import { CredentialStoreType, MCPServerType, MCPTransportType } from './chunk-YFHT5M2R.js';
 export { CredentialStoreType, MCPServerType, MCPTransportType, TOOL_STATUS_VALUES, VALID_RELATION_TYPES } from './chunk-YFHT5M2R.js';
 import { __commonJS, __require, __publicField } from './chunk-E6R6PML7.js';
@@ -212903,10 +212903,10 @@ var ContextConfigBuilder = class {
     __publicField(this, "baseURL");
     __publicField(this, "tenantId");
     __publicField(this, "projectId");
-    __publicField(this, "graphId");
+    __publicField(this, "agentId");
     this.tenantId = options.tenantId || "default";
     this.projectId = options.projectId || "default";
-    this.graphId = options.graphId || "default";
+    this.agentId = options.agentId || "default";
     this.baseURL = process.env.INKEEP_AGENTS_MANAGE_API_URL || "http://localhost:3002";
     let headers2;
     if (options.headers) {
@@ -212955,23 +212955,23 @@ var ContextConfigBuilder = class {
     );
   }
   /**
-   * Set the context (tenantId, projectId, graphId) for this context config
-   * Called by graph.setConfig() when the graph is configured
+   * Set the context (tenantId, projectId, agentId) for this context config
+   * Called by agent.setConfig() when the agent is configured
    */
-  setContext(tenantId, projectId, graphId, baseURL) {
+  setContext(tenantId, projectId, agentId, baseURL) {
     this.tenantId = tenantId;
     this.projectId = projectId;
-    this.graphId = graphId;
+    this.agentId = agentId;
     this.baseURL = baseURL;
     this.config.tenantId = tenantId;
     this.config.projectId = projectId;
-    this.config.graphId = graphId;
+    this.config.agentId = agentId;
     logger.info(
       {
         contextConfigId: this.config.id,
         tenantId: this.tenantId,
         projectId: this.projectId,
-        graphId: this.graphId
+        agentId: this.agentId
       },
       "ContextConfig context updated"
     );
@@ -212984,7 +212984,7 @@ var ContextConfigBuilder = class {
       id: this.getId(),
       tenantId: this.tenantId,
       projectId: this.projectId,
-      graphId: this.graphId,
+      agentId: this.agentId,
       headersSchema: this.getHeadersSchema(),
       contextVariables: this.getContextVariables(),
       createdAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -213075,7 +213075,7 @@ var ContextConfigBuilder = class {
     };
     try {
       const updateResponse = await fetch(
-        `${this.baseURL}/tenants/${this.tenantId}/projects/${this.projectId}/graphs/${this.graphId}/context-configs/${this.getId()}`,
+        `${this.baseURL}/tenants/${this.tenantId}/projects/${this.projectId}/agent/${this.agentId}/context-configs/${this.getId()}`,
         {
           method: "PUT",
           headers: {
@@ -213101,7 +213101,7 @@ var ContextConfigBuilder = class {
           "Context config not found, creating new config"
         );
         const createResponse = await fetch(
-          `${this.baseURL}/tenants/${this.tenantId}/projects/${this.projectId}/graphs/${this.graphId}/context-configs`,
+          `${this.baseURL}/tenants/${this.tenantId}/projects/${this.projectId}/agent/${this.agentId}/context-configs`,
           {
             method: "POST",
             headers: {
@@ -213582,7 +213582,7 @@ var getContextConfigById = (db) => async (params) => {
     where: and(
       eq(contextConfigs.tenantId, params.scopes.tenantId),
       eq(contextConfigs.projectId, params.scopes.projectId),
-      eq(contextConfigs.graphId, params.scopes.graphId),
+      eq(contextConfigs.agentId, params.scopes.agentId),
       eq(contextConfigs.id, params.id)
     )
   });
@@ -213592,7 +213592,7 @@ var listContextConfigs = (db) => async (params) => {
     where: and(
       eq(contextConfigs.tenantId, params.scopes.tenantId),
       eq(contextConfigs.projectId, params.scopes.projectId),
-      eq(contextConfigs.graphId, params.scopes.graphId)
+      eq(contextConfigs.agentId, params.scopes.agentId)
     ),
     orderBy: [desc(contextConfigs.createdAt)]
   });
@@ -213604,7 +213604,7 @@ var listContextConfigsPaginated = (db) => async (params) => {
   const whereClause = and(
     eq(contextConfigs.tenantId, params.scopes.tenantId),
     eq(contextConfigs.projectId, params.scopes.projectId),
-    eq(contextConfigs.graphId, params.scopes.graphId)
+    eq(contextConfigs.agentId, params.scopes.agentId)
   );
   const [contextConfigList, totalResult] = await Promise.all([
     db.select().from(contextConfigs).where(whereClause).limit(limit).offset(offset).orderBy(desc(contextConfigs.createdAt)),
@@ -213633,7 +213633,7 @@ var createContextConfig = (db) => async (params) => {
     id,
     tenantId: params.tenantId,
     projectId: params.projectId,
-    graphId: params.graphId,
+    agentId: params.agentId,
     headersSchema: params.headersSchema ?? null,
     contextVariables: contextVariables ?? null,
     createdAt: now,
@@ -213659,7 +213659,7 @@ var updateContextConfig = (db) => async (params) => {
     and(
       eq(contextConfigs.tenantId, params.scopes.tenantId),
       eq(contextConfigs.projectId, params.scopes.projectId),
-      eq(contextConfigs.graphId, params.scopes.graphId),
+      eq(contextConfigs.agentId, params.scopes.agentId),
       eq(contextConfigs.id, params.id)
     )
   ).returning();
@@ -213671,7 +213671,7 @@ var deleteContextConfig = (db) => async (params) => {
       and(
         eq(contextConfigs.tenantId, params.scopes.tenantId),
         eq(contextConfigs.projectId, params.scopes.projectId),
-        eq(contextConfigs.graphId, params.scopes.graphId),
+        eq(contextConfigs.agentId, params.scopes.agentId),
         eq(contextConfigs.id, params.id)
       )
     ).returning();
@@ -213690,7 +213690,7 @@ var countContextConfigs = (db) => async (params) => {
     and(
       eq(contextConfigs.tenantId, params.scopes.tenantId),
       eq(contextConfigs.projectId, params.scopes.projectId),
-      eq(contextConfigs.graphId, params.scopes.graphId)
+      eq(contextConfigs.agentId, params.scopes.agentId)
     )
   );
   const total = result[0]?.count || 0;
@@ -213700,7 +213700,7 @@ var upsertContextConfig = (db) => async (params) => {
   const scopes = {
     tenantId: params.data.tenantId,
     projectId: params.data.projectId,
-    graphId: params.data.graphId
+    agentId: params.data.agentId
   };
   if (params.data.id) {
     const existing = await getContextConfigById(db)({
@@ -213729,7 +213729,7 @@ var getExternalAgent = (db) => async (params) => {
     where: and(
       eq(externalAgents.tenantId, params.scopes.tenantId),
       eq(externalAgents.projectId, params.scopes.projectId),
-      eq(externalAgents.graphId, params.scopes.graphId),
+      eq(externalAgents.agentId, params.scopes.agentId),
       eq(externalAgents.id, params.subAgentId)
     )
   });
@@ -213740,7 +213740,7 @@ var getExternalAgentByUrl = (db) => async (params) => {
     where: and(
       eq(externalAgents.tenantId, params.scopes.tenantId),
       eq(externalAgents.projectId, params.scopes.projectId),
-      eq(externalAgents.graphId, params.scopes.graphId),
+      eq(externalAgents.agentId, params.scopes.agentId),
       eq(externalAgents.baseUrl, params.baseUrl)
     )
   });
@@ -213751,7 +213751,7 @@ var listExternalAgents = (db) => async (params) => {
     where: and(
       eq(externalAgents.tenantId, params.scopes.tenantId),
       eq(externalAgents.projectId, params.scopes.projectId),
-      eq(externalAgents.graphId, params.scopes.graphId)
+      eq(externalAgents.agentId, params.scopes.agentId)
     ),
     orderBy: [asc(externalAgents.name)]
   });
@@ -213765,14 +213765,14 @@ var listExternalAgentsPaginated = (db) => async (params) => {
       and(
         eq(externalAgents.tenantId, params.scopes.tenantId),
         eq(externalAgents.projectId, params.scopes.projectId),
-        eq(externalAgents.graphId, params.scopes.graphId)
+        eq(externalAgents.agentId, params.scopes.agentId)
       )
     ).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)
+        eq(externalAgents.agentId, params.scopes.agentId)
       )
     )
   ]);
@@ -213801,7 +213801,7 @@ var updateExternalAgent = (db) => async (params) => {
     and(
       eq(externalAgents.tenantId, params.scopes.tenantId),
       eq(externalAgents.projectId, params.scopes.projectId),
-      eq(externalAgents.graphId, params.scopes.graphId),
+      eq(externalAgents.agentId, params.scopes.agentId),
       eq(externalAgents.id, params.subAgentId)
     )
   ).returning();
@@ -213811,7 +213811,7 @@ var upsertExternalAgent = (db) => async (params) => {
   const scopes = {
     tenantId: params.data.tenantId,
     projectId: params.data.projectId,
-    graphId: params.data.graphId
+    agentId: params.data.agentId
   };
   const existing = await getExternalAgent(db)({
     scopes,
@@ -213843,7 +213843,7 @@ var deleteExternalAgent = (db) => async (params) => {
       and(
         eq(externalAgents.tenantId, params.scopes.tenantId),
         eq(externalAgents.projectId, params.scopes.projectId),
-        eq(externalAgents.graphId, params.scopes.graphId),
+        eq(externalAgents.agentId, params.scopes.agentId),
         eq(externalAgents.id, params.subAgentId)
       )
     ).returning();
@@ -213866,7 +213866,7 @@ var countExternalAgents = (db) => async (params) => {
     and(
       eq(externalAgents.tenantId, params.scopes.tenantId),
       eq(externalAgents.projectId, params.scopes.projectId),
-      eq(externalAgents.graphId, params.scopes.graphId)
+      eq(externalAgents.agentId, params.scopes.agentId)
     )
   );
   const countValue = result[0]?.count;
@@ -214010,7 +214010,7 @@ var getFunctionToolById = (db) => async (params) => {
     and(
       eq(functionTools.tenantId, params.scopes.tenantId),
       eq(functionTools.projectId, params.scopes.projectId),
-      eq(functionTools.graphId, params.scopes.graphId),
+      eq(functionTools.agentId, params.scopes.agentId),
       eq(functionTools.id, params.functionToolId)
     )
   ).limit(1);
@@ -214023,7 +214023,7 @@ var listFunctionTools = (db) => async (params) => {
   const whereClause = and(
     eq(functionTools.tenantId, params.scopes.tenantId),
     eq(functionTools.projectId, params.scopes.projectId),
-    eq(functionTools.graphId, params.scopes.graphId)
+    eq(functionTools.agentId, params.scopes.agentId)
   );
   const [functionToolsDbResults, totalResult] = await Promise.all([
     db.select().from(functionTools).where(whereClause).limit(limit).offset(offset).orderBy(desc(functionTools.createdAt)),
@@ -214038,11 +214038,11 @@ var listFunctionTools = (db) => async (params) => {
 };
 var createFunctionTool = (db) => async (params) => {
   const { data, scopes } = params;
-  const { tenantId, projectId, graphId } = scopes;
+  const { tenantId, projectId, agentId } = scopes;
   const [created] = await db.insert(functionTools).values({
     tenantId,
     projectId,
-    graphId,
+    agentId,
     id: data.id,
     name: data.name,
     description: data.description,
@@ -214061,7 +214061,7 @@ var updateFunctionTool = (db) => async (params) => {
     and(
       eq(functionTools.tenantId, params.scopes.tenantId),
       eq(functionTools.projectId, params.scopes.projectId),
-      eq(functionTools.graphId, params.scopes.graphId),
+      eq(functionTools.agentId, params.scopes.agentId),
       eq(functionTools.id, params.functionToolId)
     )
   ).returning();
@@ -214072,7 +214072,7 @@ var deleteFunctionTool = (db) => async (params) => {
     and(
       eq(functionTools.tenantId, params.scopes.tenantId),
       eq(functionTools.projectId, params.scopes.projectId),
-      eq(functionTools.graphId, params.scopes.graphId),
+      eq(functionTools.agentId, params.scopes.agentId),
       eq(functionTools.id, params.functionToolId)
     )
   ).returning();
@@ -214082,7 +214082,7 @@ var upsertFunctionTool = (db) => async (params) => {
   const scopes = {
     tenantId: params.scopes.tenantId,
     projectId: params.scopes.projectId,
-    graphId: params.scopes.graphId
+    agentId: params.scopes.agentId
   };
   const existing = await getFunctionToolById(db)({
     scopes,
@@ -214108,17 +214108,17 @@ var upsertFunctionTool = (db) => async (params) => {
 var getFunctionToolsForSubAgent = (db) => {
   return async (params) => {
     const { scopes, subAgentId } = params;
-    const { tenantId, projectId, graphId } = scopes;
+    const { tenantId, projectId, agentId } = scopes;
     try {
       const functionToolsList = await listFunctionTools(db)({
-        scopes: { tenantId, projectId, graphId },
+        scopes: { tenantId, projectId, agentId },
         pagination: { page: 1, limit: 1e3 }
       });
       const relations = await db.select().from(agentFunctionToolRelations).where(
         and(
           eq(agentFunctionToolRelations.tenantId, tenantId),
           eq(agentFunctionToolRelations.projectId, projectId),
-          eq(agentFunctionToolRelations.graphId, graphId),
+          eq(agentFunctionToolRelations.agentId, agentId),
           eq(agentFunctionToolRelations.subAgentId, subAgentId)
         )
       );
@@ -214132,7 +214132,7 @@ var getFunctionToolsForSubAgent = (db) => {
       };
     } catch (error) {
       logger3.error(
-        { tenantId, projectId, graphId, subAgentId, error },
+        { tenantId, projectId, agentId, subAgentId, error },
         "Failed to get function tools for agent"
       );
       throw error;
@@ -214155,25 +214155,25 @@ var upsertSubAgentFunctionToolRelation = (db) => async (params) => {
 var addFunctionToolToSubAgent = (db) => {
   return async (params) => {
     const { scopes, subAgentId, functionToolId } = params;
-    const { tenantId, projectId, graphId } = scopes;
+    const { tenantId, projectId, agentId } = scopes;
     try {
       const relationId = nanoid();
       await db.insert(agentFunctionToolRelations).values({
         id: relationId,
         tenantId,
         projectId,
-        graphId,
+        agentId,
         subAgentId,
         functionToolId
       });
       logger3.info(
-        { tenantId, projectId, graphId, subAgentId, functionToolId, relationId },
+        { tenantId, projectId, agentId, subAgentId, functionToolId, relationId },
         "Function tool added to agent"
       );
       return { id: relationId };
     } catch (error) {
       logger3.error(
-        { tenantId, projectId, graphId, subAgentId, functionToolId, error },
+        { tenantId, projectId, agentId, subAgentId, functionToolId, error },
         "Failed to add function tool to agent"
       );
       throw error;
@@ -214183,7 +214183,7 @@ var addFunctionToolToSubAgent = (db) => {
 var updateSubAgentFunctionToolRelation = (db) => {
   return async (params) => {
     const { scopes, relationId, data } = params;
-    const { tenantId, projectId, graphId } = scopes;
+    const { tenantId, projectId, agentId } = scopes;
     try {
       await db.update(agentFunctionToolRelations).set({
         subAgentId: data.subAgentId,
@@ -214193,17 +214193,17 @@ var updateSubAgentFunctionToolRelation = (db) => {
           eq(agentFunctionToolRelations.id, relationId),
           eq(agentFunctionToolRelations.tenantId, tenantId),
           eq(agentFunctionToolRelations.projectId, projectId),
-          eq(agentFunctionToolRelations.graphId, graphId)
+          eq(agentFunctionToolRelations.agentId, agentId)
         )
       );
       logger3.info(
-        { tenantId, projectId, graphId, relationId, data },
+        { tenantId, projectId, agentId, relationId, data },
         "Agent-function tool relation updated"
       );
       return { id: relationId };
     } catch (error) {
       logger3.error(
-        { tenantId, projectId, graphId, relationId, data, error },
+        { tenantId, projectId, agentId, relationId, data, error },
         "Failed to update agent-function tool relation"
       );
       throw error;
@@ -214215,7 +214215,7 @@ var getAgentRelationById = (db) => async (params) => {
     where: and(
       eq(subAgentRelations.tenantId, params.scopes.tenantId),
       eq(subAgentRelations.projectId, params.scopes.projectId),
-      eq(subAgentRelations.graphId, params.scopes.graphId),
+      eq(subAgentRelations.agentId, params.scopes.agentId),
       eq(subAgentRelations.id, params.relationId)
     )
   });
@@ -214227,7 +214227,7 @@ var listAgentRelations = (db) => async (params) => {
   const whereClause = and(
     eq(subAgentRelations.tenantId, params.scopes.tenantId),
     eq(subAgentRelations.projectId, params.scopes.projectId),
-    eq(subAgentRelations.graphId, params.scopes.graphId)
+    eq(subAgentRelations.agentId, params.scopes.agentId)
   );
   const [data, totalResult] = await Promise.all([
     db.select().from(subAgentRelations).where(whereClause).limit(limit).offset(offset).orderBy(desc(subAgentRelations.createdAt)),
@@ -214242,17 +214242,17 @@ var getAgentRelations = (db) => async (params) => {
     where: and(
       eq(subAgentRelations.tenantId, params.scopes.tenantId),
       eq(subAgentRelations.projectId, params.scopes.projectId),
-      eq(subAgentRelations.graphId, params.scopes.graphId),
+      eq(subAgentRelations.agentId, params.scopes.agentId),
       eq(subAgentRelations.sourceSubAgentId, params.scopes.subAgentId)
     )
   });
 };
-var getAgentRelationsByGraph = (db) => async (params) => {
+var getAgentRelationsByAgent = (db) => async (params) => {
   return await db.query.subAgentRelations.findMany({
     where: and(
       eq(subAgentRelations.tenantId, params.scopes.tenantId),
       eq(subAgentRelations.projectId, params.scopes.projectId),
-      eq(subAgentRelations.graphId, params.scopes.graphId)
+      eq(subAgentRelations.agentId, params.scopes.agentId)
     )
   });
 };
@@ -214263,7 +214263,7 @@ var getAgentRelationsBySource = (db) => async (params) => {
   const whereClause = and(
     eq(subAgentRelations.tenantId, params.scopes.tenantId),
     eq(subAgentRelations.projectId, params.scopes.projectId),
-    eq(subAgentRelations.graphId, params.scopes.graphId),
+    eq(subAgentRelations.agentId, params.scopes.agentId),
     eq(subAgentRelations.sourceSubAgentId, params.sourceSubAgentId)
   );
   const [data, totalResult] = await Promise.all([
@@ -214284,7 +214284,7 @@ var getAgentRelationsByTarget = (db) => async (params) => {
   const whereClause = and(
     eq(subAgentRelations.tenantId, params.scopes.tenantId),
     eq(subAgentRelations.projectId, params.scopes.projectId),
-    eq(subAgentRelations.graphId, params.scopes.graphId),
+    eq(subAgentRelations.agentId, params.scopes.agentId),
     eq(subAgentRelations.targetSubAgentId, params.targetSubAgentId)
   );
   const [data, totalResult] = await Promise.all([
@@ -214305,7 +214305,7 @@ var getExternalAgentRelations = (db) => async (params) => {
   const whereClause = and(
     eq(subAgentRelations.tenantId, params.scopes.tenantId),
     eq(subAgentRelations.projectId, params.scopes.projectId),
-    eq(subAgentRelations.graphId, params.scopes.graphId),
+    eq(subAgentRelations.agentId, params.scopes.agentId),
     eq(subAgentRelations.externalSubAgentId, params.externalSubAgentId)
   );
   const [data, totalResult] = await Promise.all([
@@ -214319,7 +214319,7 @@ var getExternalAgentRelations = (db) => async (params) => {
     pagination: { page, limit, total, pages }
   };
 };
-var getRelatedAgentsForGraph = (db) => async (params) => {
+var getRelatedAgentsForAgent = (db) => async (params) => {
   const internalRelations = await db.select({
     id: subAgents.id,
     name: subAgents.name,
@@ -214331,13 +214331,13 @@ var getRelatedAgentsForGraph = (db) => async (params) => {
       eq(subAgentRelations.targetSubAgentId, subAgents.id),
       eq(subAgentRelations.tenantId, subAgents.tenantId),
       eq(subAgentRelations.projectId, subAgents.projectId),
-      eq(subAgentRelations.graphId, subAgents.graphId)
+      eq(subAgentRelations.agentId, subAgents.agentId)
     )
   ).where(
     and(
       eq(subAgentRelations.tenantId, params.scopes.tenantId),
       eq(subAgentRelations.projectId, params.scopes.projectId),
-      eq(subAgentRelations.graphId, params.scopes.graphId),
+      eq(subAgentRelations.agentId, params.scopes.agentId),
       eq(subAgentRelations.sourceSubAgentId, params.subAgentId),
       isNotNull(subAgentRelations.targetSubAgentId)
     )
@@ -214357,13 +214357,13 @@ var getRelatedAgentsForGraph = (db) => async (params) => {
       eq(subAgentRelations.externalSubAgentId, externalAgents.id),
       eq(subAgentRelations.tenantId, externalAgents.tenantId),
       eq(subAgentRelations.projectId, externalAgents.projectId),
-      eq(subAgentRelations.graphId, externalAgents.graphId)
+      eq(subAgentRelations.agentId, externalAgents.agentId)
     )
   ).where(
     and(
       eq(subAgentRelations.tenantId, params.scopes.tenantId),
       eq(subAgentRelations.projectId, params.scopes.projectId),
-      eq(subAgentRelations.graphId, params.scopes.graphId),
+      eq(subAgentRelations.agentId, params.scopes.agentId),
       eq(subAgentRelations.sourceSubAgentId, params.subAgentId),
       isNotNull(subAgentRelations.externalSubAgentId)
     )
@@ -214391,7 +214391,7 @@ var getAgentRelationByParams = (db) => async (params) => {
   const whereConditions = [
     eq(subAgentRelations.tenantId, params.scopes.tenantId),
     eq(subAgentRelations.projectId, params.scopes.projectId),
-    eq(subAgentRelations.graphId, params.scopes.graphId),
+    eq(subAgentRelations.agentId, params.scopes.agentId),
     eq(subAgentRelations.sourceSubAgentId, params.sourceSubAgentId),
     eq(subAgentRelations.relationType, params.relationType)
   ];
@@ -214407,7 +214407,7 @@ var getAgentRelationByParams = (db) => async (params) => {
 };
 var upsertAgentRelation = (db) => async (params) => {
   const existing = await getAgentRelationByParams(db)({
-    scopes: { tenantId: params.tenantId, projectId: params.projectId, graphId: params.graphId },
+    scopes: { tenantId: params.tenantId, projectId: params.projectId, agentId: params.agentId },
     sourceSubAgentId: params.sourceSubAgentId,
     targetSubAgentId: params.targetSubAgentId,
     externalSubAgentId: params.externalSubAgentId,
@@ -214433,7 +214433,7 @@ var updateAgentRelation = (db) => async (params) => {
     and(
       eq(subAgentRelations.tenantId, params.scopes.tenantId),
       eq(subAgentRelations.projectId, params.scopes.projectId),
-      eq(subAgentRelations.graphId, params.scopes.graphId),
+      eq(subAgentRelations.agentId, params.scopes.agentId),
       eq(subAgentRelations.id, params.relationId)
     )
   ).returning();
@@ -214444,17 +214444,17 @@ var deleteSubAgentRelation = (db) => async (params) => {
     and(
       eq(subAgentRelations.tenantId, params.scopes.tenantId),
       eq(subAgentRelations.projectId, params.scopes.projectId),
-      eq(subAgentRelations.graphId, params.scopes.graphId),
+      eq(subAgentRelations.agentId, params.scopes.agentId),
       eq(subAgentRelations.id, params.relationId)
     )
   );
   return (result.rowsAffected || 0) > 0;
 };
-var deleteAgentRelationsByGraph = (db) => async (params) => {
+var deleteAgentRelationsByAgent = (db) => async (params) => {
   const result = await db.delete(subAgentRelations).where(
     and(
       eq(subAgentRelations.tenantId, params.scopes.tenantId),
-      eq(subAgentRelations.graphId, params.scopes.graphId)
+      eq(subAgentRelations.agentId, params.scopes.agentId)
     )
   );
   return (result.rowsAffected || 0) > 0;
@@ -214465,7 +214465,7 @@ var createAgentToolRelation = (db) => async (params) => {
     id: finalRelationId,
     tenantId: params.scopes.tenantId,
     projectId: params.scopes.projectId,
-    graphId: params.scopes.graphId,
+    agentId: params.scopes.agentId,
     subAgentId: params.data.subAgentId,
     toolId: params.data.toolId,
     selectedTools: params.data.selectedTools,
@@ -214482,7 +214482,7 @@ var updateAgentToolRelation = (db) => async (params) => {
     and(
       eq(subAgentToolRelations.tenantId, params.scopes.tenantId),
       eq(subAgentToolRelations.projectId, params.scopes.projectId),
-      eq(subAgentToolRelations.graphId, params.scopes.graphId),
+      eq(subAgentToolRelations.agentId, params.scopes.agentId),
       eq(subAgentToolRelations.id, params.relationId)
     )
   ).returning();
@@ -214493,7 +214493,7 @@ var deleteAgentToolRelation = (db) => async (params) => {
     and(
       eq(subAgentToolRelations.tenantId, params.scopes.tenantId),
       eq(subAgentToolRelations.projectId, params.scopes.projectId),
-      eq(subAgentToolRelations.graphId, params.scopes.graphId),
+      eq(subAgentToolRelations.agentId, params.scopes.agentId),
       eq(subAgentToolRelations.id, params.relationId)
     )
   );
@@ -214504,7 +214504,7 @@ var deleteAgentToolRelationByAgent = (db) => async (params) => {
     and(
       eq(subAgentToolRelations.tenantId, params.scopes.tenantId),
       eq(subAgentToolRelations.projectId, params.scopes.projectId),
-      eq(subAgentToolRelations.graphId, params.scopes.graphId),
+      eq(subAgentToolRelations.agentId, params.scopes.agentId),
       eq(subAgentToolRelations.subAgentId, params.scopes.subAgentId)
     )
   );
@@ -214515,7 +214515,7 @@ var getAgentToolRelationById = (db) => async (params) => {
     where: and(
       eq(subAgentToolRelations.tenantId, params.scopes.tenantId),
       eq(subAgentToolRelations.projectId, params.scopes.projectId),
-      eq(subAgentToolRelations.graphId, params.scopes.graphId),
+      eq(subAgentToolRelations.agentId, params.scopes.agentId),
       eq(subAgentToolRelations.id, params.relationId)
     )
   });
@@ -214556,7 +214556,7 @@ var getAgentToolRelationByTool = (db) => async (params) => {
       and(
         eq(subAgentToolRelations.tenantId, params.scopes.tenantId),
         eq(subAgentToolRelations.projectId, params.scopes.projectId),
-        eq(subAgentToolRelations.graphId, params.scopes.graphId),
+        eq(subAgentToolRelations.agentId, params.scopes.agentId),
         eq(subAgentToolRelations.toolId, params.toolId)
       )
     ).limit(limit).offset(offset).orderBy(desc(subAgentToolRelations.createdAt)),
@@ -214564,7 +214564,7 @@ var getAgentToolRelationByTool = (db) => async (params) => {
       and(
         eq(subAgentToolRelations.tenantId, params.scopes.tenantId),
         eq(subAgentToolRelations.projectId, params.scopes.projectId),
-        eq(subAgentToolRelations.graphId, params.scopes.graphId),
+        eq(subAgentToolRelations.agentId, params.scopes.agentId),
         eq(subAgentToolRelations.toolId, params.toolId)
       )
     )
@@ -214585,14 +214585,14 @@ var listAgentToolRelations = (db) => async (params) => {
       and(
         eq(subAgentToolRelations.tenantId, params.scopes.tenantId),
         eq(subAgentToolRelations.projectId, params.scopes.projectId),
-        eq(subAgentToolRelations.graphId, params.scopes.graphId)
+        eq(subAgentToolRelations.agentId, params.scopes.agentId)
       )
     ).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.agentId, params.scopes.agentId)
       )
     )
   ]);
@@ -214643,7 +214643,7 @@ var getToolsForAgent = (db) => async (params) => {
       and(
         eq(subAgentToolRelations.tenantId, params.scopes.tenantId),
         eq(subAgentToolRelations.projectId, params.scopes.projectId),
-        eq(subAgentToolRelations.graphId, params.scopes.graphId),
+        eq(subAgentToolRelations.agentId, params.scopes.agentId),
         eq(subAgentToolRelations.subAgentId, params.scopes.subAgentId)
       )
     ).limit(limit).offset(offset).orderBy(desc(subAgentToolRelations.createdAt)),
@@ -214651,7 +214651,7 @@ var getToolsForAgent = (db) => async (params) => {
       and(
         eq(subAgentToolRelations.tenantId, params.scopes.tenantId),
         eq(subAgentToolRelations.projectId, params.scopes.projectId),
-        eq(subAgentToolRelations.graphId, params.scopes.graphId),
+        eq(subAgentToolRelations.agentId, params.scopes.agentId),
         eq(subAgentToolRelations.subAgentId, params.scopes.subAgentId)
       )
     )
@@ -214694,13 +214694,13 @@ var getAgentsForTool = (db) => async (params) => {
         eq(subAgentToolRelations.subAgentId, subAgents.id),
         eq(subAgentToolRelations.tenantId, subAgents.tenantId),
         eq(subAgentToolRelations.projectId, subAgents.projectId),
-        eq(subAgentToolRelations.graphId, subAgents.graphId)
+        eq(subAgentToolRelations.agentId, subAgents.agentId)
       )
     ).where(
       and(
         eq(subAgentToolRelations.tenantId, params.scopes.tenantId),
         eq(subAgentToolRelations.projectId, params.scopes.projectId),
-        eq(subAgentToolRelations.graphId, params.scopes.graphId),
+        eq(subAgentToolRelations.agentId, params.scopes.agentId),
         eq(subAgentToolRelations.toolId, params.toolId)
       )
     ).limit(limit).offset(offset).orderBy(desc(subAgentToolRelations.createdAt)),
@@ -214708,7 +214708,7 @@ var getAgentsForTool = (db) => async (params) => {
       and(
         eq(subAgentToolRelations.tenantId, params.scopes.tenantId),
         eq(subAgentToolRelations.projectId, params.scopes.projectId),
-        eq(subAgentToolRelations.graphId, params.scopes.graphId),
+        eq(subAgentToolRelations.agentId, params.scopes.agentId),
         eq(subAgentToolRelations.toolId, params.toolId)
       )
     )
@@ -214725,7 +214725,7 @@ var validateInternalSubAgent = (db) => async (params) => {
     and(
       eq(subAgents.tenantId, params.scopes.tenantId),
       eq(subAgents.projectId, params.scopes.projectId),
-      eq(subAgents.graphId, params.scopes.graphId),
+      eq(subAgents.agentId, params.scopes.agentId),
       eq(subAgents.id, params.scopes.subAgentId)
     )
   ).limit(1);
@@ -214736,7 +214736,7 @@ var validateExternalAgent = (db) => async (params) => {
     and(
       eq(externalAgents.tenantId, params.scopes.tenantId),
       eq(externalAgents.projectId, params.scopes.projectId),
-      eq(externalAgents.graphId, params.scopes.graphId),
+      eq(externalAgents.agentId, params.scopes.agentId),
       eq(externalAgents.id, params.scopes.subAgentId)
     )
   ).limit(1);
@@ -214747,7 +214747,7 @@ var getSubAgentById = (db) => async (params) => {
     where: and(
       eq(subAgents.tenantId, params.scopes.tenantId),
       eq(subAgents.projectId, params.scopes.projectId),
-      eq(subAgents.graphId, params.scopes.graphId),
+      eq(subAgents.agentId, params.scopes.agentId),
       eq(subAgents.id, params.subAgentId)
     )
   });
@@ -214758,7 +214758,7 @@ var listSubAgents = (db) => async (params) => {
     where: and(
       eq(subAgents.tenantId, params.scopes.tenantId),
       eq(subAgents.projectId, params.scopes.projectId),
-      eq(subAgents.graphId, params.scopes.graphId)
+      eq(subAgents.agentId, params.scopes.agentId)
     )
   });
 };
@@ -214769,7 +214769,7 @@ var listSubAgentsPaginated = (db) => async (params) => {
   const whereClause = and(
     eq(subAgents.tenantId, params.scopes.tenantId),
     eq(subAgents.projectId, params.scopes.projectId),
-    eq(subAgents.graphId, params.scopes.graphId)
+    eq(subAgents.agentId, params.scopes.agentId)
   );
   const [data, totalResult] = await Promise.all([
     db.select().from(subAgents).where(whereClause).limit(limit).offset(offset).orderBy(desc(subAgents.createdAt)),
@@ -214801,7 +214801,7 @@ var updateSubAgent = (db) => async (params) => {
     and(
       eq(subAgents.tenantId, params.scopes.tenantId),
       eq(subAgents.projectId, params.scopes.projectId),
-      eq(subAgents.graphId, params.scopes.graphId),
+      eq(subAgents.agentId, params.scopes.agentId),
       eq(subAgents.id, params.subAgentId)
     )
   ).returning();
@@ -214811,7 +214811,7 @@ var upsertSubAgent = (db) => async (params) => {
   const scopes = {
     tenantId: params.data.tenantId,
     projectId: params.data.projectId,
-    graphId: params.data.graphId
+    agentId: params.data.agentId
   };
   const existing = await getSubAgentById(db)({
     scopes,
@@ -214843,7 +214843,7 @@ var deleteSubAgent = (db) => async (params) => {
     and(
       eq(subAgents.tenantId, params.scopes.tenantId),
       eq(subAgents.projectId, params.scopes.projectId),
-      eq(subAgents.graphId, params.scopes.graphId),
+      eq(subAgents.agentId, params.scopes.agentId),
       eq(subAgents.id, params.subAgentId)
     )
   );
@@ -214861,7 +214861,7 @@ var getSubAgentsByIds = (db) => async (params) => {
     and(
       eq(subAgents.tenantId, params.scopes.tenantId),
       eq(subAgents.projectId, params.scopes.projectId),
-      eq(subAgents.graphId, params.scopes.graphId),
+      eq(subAgents.agentId, params.scopes.agentId),
       inArray(subAgents.id, params.subAgentIds)
     )
   );
@@ -215329,7 +215329,7 @@ function createExecutionContext(params) {
     apiKey: params.apiKey,
     tenantId: params.tenantId,
     projectId: params.projectId,
-    graphId: params.graphId,
+    agentId: params.agentId,
     baseUrl: params.baseUrl || process.env.API_URL || "http://localhost:3003",
     apiKeyId: params.apiKeyId
   };
@@ -215949,7 +215949,7 @@ var addToolToAgent = (db) => async (params) => {
     id,
     tenantId: params.scopes.tenantId,
     projectId: params.scopes.projectId,
-    graphId: params.scopes.graphId,
+    agentId: params.scopes.agentId,
     subAgentId: params.subAgentId,
     toolId: params.toolId,
     selectedTools: params.selectedTools,
@@ -215964,7 +215964,7 @@ var removeToolFromAgent = (db) => async (params) => {
     and(
       eq(subAgentToolRelations.tenantId, params.scopes.tenantId),
       eq(subAgentToolRelations.projectId, params.scopes.projectId),
-      eq(subAgentToolRelations.graphId, params.scopes.graphId),
+      eq(subAgentToolRelations.agentId, params.scopes.agentId),
       eq(subAgentToolRelations.subAgentId, params.subAgentId),
       eq(subAgentToolRelations.toolId, params.toolId)
     )
@@ -216009,23 +216009,23 @@ var upsertTool = (db) => async (params) => {
   }
 };
 
-// src/data-access/agentGraphs.ts
-var getAgentGraphById = (db) => async (params) => {
-  const result = await db.query.agentGraph.findFirst({
+// src/data-access/agents.ts
+var getAgentById = (db) => async (params) => {
+  const result = await db.query.agents.findFirst({
     where: and(
-      eq(agentGraph.tenantId, params.scopes.tenantId),
-      eq(agentGraph.projectId, params.scopes.projectId),
-      eq(agentGraph.id, params.scopes.graphId)
+      eq(agents.tenantId, params.scopes.tenantId),
+      eq(agents.projectId, params.scopes.projectId),
+      eq(agents.id, params.scopes.agentId)
     )
   });
   return result ?? null;
 };
-var getAgentGraphWithDefaultSubAgent = (db) => async (params) => {
-  const result = await db.query.agentGraph.findFirst({
+var getAgentWithDefaultSubAgent = (db) => async (params) => {
+  const result = await db.query.agents.findFirst({
     where: and(
-      eq(agentGraph.tenantId, params.scopes.tenantId),
-      eq(agentGraph.projectId, params.scopes.projectId),
-      eq(agentGraph.id, params.scopes.graphId)
+      eq(agents.tenantId, params.scopes.tenantId),
+      eq(agents.projectId, params.scopes.projectId),
+      eq(agents.id, params.scopes.agentId)
     ),
     with: {
       defaultSubAgent: true
@@ -216033,26 +216033,26 @@ var getAgentGraphWithDefaultSubAgent = (db) => async (params) => {
   });
   return result ?? null;
 };
-var listAgentGraphs = (db) => async (params) => {
-  return await db.query.agentGraph.findMany({
+var listAgents = (db) => async (params) => {
+  return await db.query.agents.findMany({
     where: and(
-      eq(agentGraph.tenantId, params.scopes.tenantId),
-      eq(agentGraph.projectId, params.scopes.projectId)
+      eq(agents.tenantId, params.scopes.tenantId),
+      eq(agents.projectId, params.scopes.projectId)
     )
   });
 };
-var listAgentGraphsPaginated = (db) => async (params) => {
+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(agentGraph.tenantId, params.scopes.tenantId),
-    eq(agentGraph.projectId, params.scopes.projectId)
+    eq(agents.tenantId, params.scopes.tenantId),
+    eq(agents.projectId, params.scopes.projectId)
   );
-  const query = db.select().from(agentGraph).where(whereClause).limit(limit).offset(offset).orderBy(desc(agentGraph.createdAt));
+  const query = db.select().from(agents).where(whereClause).limit(limit).offset(offset).orderBy(desc(agents.createdAt));
   const [data, totalResult] = await Promise.all([
     query,
-    db.select({ count: count() }).from(agentGraph).where(whereClause)
+    db.select({ count: count() }).from(agents).where(whereClause)
   ]);
   const total = totalResult[0]?.count || 0;
   const pages = Math.ceil(total / limit);
@@ -216061,74 +216061,62 @@ var listAgentGraphsPaginated = (db) => async (params) => {
     pagination: { page, limit, total, pages }
   };
 };
-var createAgentGraph = (db) => async (data) => {
+var createAgent = (db) => async (data) => {
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const insertData = {
     ...data,
     createdAt: now,
-    updatedAt: now
+    updatedAt: now,
+    ...data.description !== void 0 && { description: data.description },
+    ...data.contextConfigId !== void 0 && { contextConfigId: data.contextConfigId },
+    ...data.models !== void 0 && { models: data.models },
+    ...data.statusUpdates !== void 0 && { statusUpdates: data.statusUpdates },
+    ...data.prompt !== void 0 && { prompt: data.prompt },
+    ...data.stopWhen !== void 0 && { stopWhen: data.stopWhen }
   };
-  if (data.description !== void 0) {
-    insertData.description = data.description;
-  }
-  if (data.contextConfigId !== void 0) {
-    insertData.contextConfigId = data.contextConfigId;
-  }
-  if (data.models !== void 0) {
-    insertData.models = data.models;
-  }
-  if (data.statusUpdates !== void 0) {
-    insertData.statusUpdates = data.statusUpdates;
-  }
-  if (data.graphPrompt !== void 0) {
-    insertData.graphPrompt = data.graphPrompt;
-  }
-  if (data.stopWhen !== void 0) {
-    insertData.stopWhen = data.stopWhen;
-  }
-  const graph = await db.insert(agentGraph).values(insertData).returning();
-  return graph[0];
+  const agent = await db.insert(agents).values(insertData).returning();
+  return agent[0];
 };
-var updateAgentGraph = (db) => async (params) => {
+var updateAgent = (db) => async (params) => {
   const data = params.data;
+  const updateData = {
+    ...data,
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
   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;
+      updateData.models = null;
     }
   }
   if (data.statusUpdates !== void 0) {
     if (!data.statusUpdates) {
-      data.statusUpdates = null;
+      updateData.statusUpdates = null;
     }
   }
   if (data.contextConfigId !== void 0 && !data.contextConfigId) {
-    data.contextConfigId = null;
+    updateData.contextConfigId = null;
   }
-  if (data.graphPrompt !== void 0 && !data.graphPrompt) {
-    data.graphPrompt = null;
+  if (data.prompt !== void 0 && !data.prompt) {
+    updateData.prompt = null;
   }
   if (data.stopWhen !== void 0 && !data.stopWhen) {
-    data.stopWhen = null;
+    updateData.stopWhen = null;
   }
-  const updateData = {
-    ...data,
-    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-  };
-  const graph = await db.update(agentGraph).set(updateData).where(
+  const agent = await db.update(agents).set(updateData).where(
     and(
-      eq(agentGraph.tenantId, params.scopes.tenantId),
-      eq(agentGraph.projectId, params.scopes.projectId),
-      eq(agentGraph.id, params.scopes.graphId)
+      eq(agents.tenantId, params.scopes.tenantId),
+      eq(agents.projectId, params.scopes.projectId),
+      eq(agents.id, params.scopes.agentId)
     )
   ).returning();
-  return graph[0] ?? null;
+  return agent[0] ?? null;
 };
-var deleteAgentGraph = (db) => async (params) => {
-  const result = await db.delete(agentGraph).where(
+var deleteAgent = (db) => async (params) => {
+  const result = await db.delete(agents).where(
     and(
-      eq(agentGraph.tenantId, params.scopes.tenantId),
-      eq(agentGraph.projectId, params.scopes.projectId),
-      eq(agentGraph.id, params.scopes.graphId)
+      eq(agents.tenantId, params.scopes.tenantId),
+      eq(agents.projectId, params.scopes.projectId),
+      eq(agents.id, params.scopes.agentId)
     )
   ).returning();
   return result.length > 0;
@@ -216136,7 +216124,10 @@ var deleteAgentGraph = (db) => async (params) => {
 var fetchComponentRelationships = (db) => async (scopes, subAgentIds, config) => {
   const componentsObject = {};
   if (subAgentIds.length > 0) {
-    const results = await db.select(config.selectFields).from(config.relationTable).innerJoin(config.componentTable, eq(config.relationIdField, config.componentIdField)).where(
+    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),
@@ -216149,20 +216140,19 @@ var fetchComponentRelationships = (db) => async (scopes, subAgentIds, config) =>
   }
   return componentsObject;
 };
-var getGraphAgentInfos = (db) => async ({
-  scopes,
-  graphId,
+var getAgentSubAgentInfos = (db) => async ({
+  scopes: { tenantId, projectId },
+  agentId,
   subAgentId
 }) => {
-  const { tenantId, projectId } = scopes;
-  const graph = await getAgentGraphById(db)({
-    scopes: { tenantId, projectId, graphId }
+  const agent = await getAgentById(db)({
+    scopes: { tenantId, projectId, agentId }
   });
-  if (!graph) {
-    throw new Error(`Agent graph with ID ${graphId} not found for tenant ${tenantId}`);
+  if (!agent) {
+    throw new Error(`Agent with ID ${agentId} not found for tenant ${tenantId}`);
   }
   const relations = await getAgentRelations(db)({
-    scopes: { tenantId, projectId, graphId, subAgentId }
+    scopes: { tenantId, projectId, agentId, subAgentId }
   });
   const targetSubAgentIds = relations.map((relation) => relation.targetSubAgentId).filter((id) => id !== null);
   if (targetSubAgentIds.length === 0) {
@@ -216170,48 +216160,45 @@ var getGraphAgentInfos = (db) => async ({
   }
   const agentInfos = await Promise.all(
     targetSubAgentIds.map(async (subAgentId2) => {
-      const agent = await getSubAgentById(db)({
-        scopes: { tenantId, projectId, graphId },
+      const agent2 = await getSubAgentById(db)({
+        scopes: { tenantId, projectId, agentId },
         subAgentId: subAgentId2
       });
-      if (agent !== void 0) {
-        return { id: agent.id, name: agent.name, description: agent.description };
-      }
-      return null;
+      return agent2 ? { id: agent2.id, name: agent2.name, description: agent2.description } : null;
     })
   );
-  return agentInfos.filter((agent) => agent !== null);
+  return agentInfos.filter((agent2) => agent2 !== null);
 };
-var getFullGraphDefinition = (db) => async ({
-  scopes: { tenantId, projectId, graphId }
+var getFullAgentDefinition = (db) => async ({
+  scopes: { tenantId, projectId, agentId }
 }) => {
-  const graph = await getAgentGraphById(db)({
-    scopes: { tenantId, projectId, graphId }
+  const agent = await getAgentById(db)({
+    scopes: { tenantId, projectId, agentId }
   });
-  if (!graph) {
+  if (!agent) {
     return null;
   }
-  const graphRelations = await getAgentRelationsByGraph(db)({
-    scopes: { tenantId, projectId, graphId }
+  const agentRelations2 = await getAgentRelationsByAgent(db)({
+    scopes: { tenantId, projectId, agentId }
   });
-  const graphSubAgents = await db.query.subAgents.findMany({
+  const agentSubAgents = await db.query.subAgents.findMany({
     where: and(
       eq(subAgents.tenantId, tenantId),
       eq(subAgents.projectId, projectId),
-      eq(subAgents.graphId, graphId)
+      eq(subAgents.agentId, agentId)
     )
   });
   const externalSubAgentIds = /* @__PURE__ */ new Set();
-  for (const relation of graphRelations) {
+  for (const relation of agentRelations2) {
     if (relation.externalSubAgentId) {
       externalSubAgentIds.add(relation.externalSubAgentId);
     }
   }
   const processedSubAgents = await Promise.all(
-    graphSubAgents.map(async (agent) => {
-      if (!agent) return null;
-      const subAgentRelationsList = graphRelations.filter(
-        (relation) => relation.sourceSubAgentId === agent.id
+    agentSubAgents.map(async (agent2) => {
+      if (!agent2) return null;
+      const subAgentRelationsList = agentRelations2.filter(
+        (relation) => relation.sourceSubAgentId === agent2.id
       );
       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);
@@ -216241,8 +216228,8 @@ var getFullGraphDefinition = (db) => async ({
         and(
           eq(subAgentToolRelations.tenantId, tenantId),
           eq(subAgentToolRelations.projectId, projectId),
-          eq(subAgentToolRelations.graphId, graphId),
-          eq(subAgentToolRelations.subAgentId, agent.id)
+          eq(subAgentToolRelations.agentId, agentId),
+          eq(subAgentToolRelations.subAgentId, agent2.id)
         )
       );
       const agentFunctionTools = await db.select({
@@ -216254,7 +216241,7 @@ var getFullGraphDefinition = (db) => async ({
         updatedAt: functionTools.updatedAt,
         tenantId: functionTools.tenantId,
         projectId: functionTools.projectId,
-        graphId: functionTools.graphId,
+        agentId: functionTools.agentId,
         agentToolRelationId: agentFunctionToolRelations.id
       }).from(agentFunctionToolRelations).innerJoin(
         functionTools,
@@ -216262,27 +216249,27 @@ var getFullGraphDefinition = (db) => async ({
           eq(agentFunctionToolRelations.functionToolId, functionTools.id),
           eq(agentFunctionToolRelations.tenantId, functionTools.tenantId),
           eq(agentFunctionToolRelations.projectId, functionTools.projectId),
-          eq(agentFunctionToolRelations.graphId, functionTools.graphId)
+          eq(agentFunctionToolRelations.agentId, functionTools.agentId)
         )
       ).where(
         and(
           eq(agentFunctionToolRelations.tenantId, tenantId),
           eq(agentFunctionToolRelations.projectId, projectId),
-          eq(agentFunctionToolRelations.graphId, graphId),
-          eq(agentFunctionToolRelations.subAgentId, agent.id)
+          eq(agentFunctionToolRelations.agentId, agentId),
+          eq(agentFunctionToolRelations.subAgentId, agent2.id)
         )
       );
       const agentDataComponentRelations = await db.query.subAgentDataComponents.findMany({
         where: and(
           eq(subAgentDataComponents.tenantId, tenantId),
-          eq(subAgentDataComponents.subAgentId, agent.id)
+          eq(subAgentDataComponents.subAgentId, agent2.id)
         )
       });
       const agentDataComponentIds = agentDataComponentRelations.map((rel) => rel.dataComponentId);
       const agentArtifactComponentRelations = await db.query.subAgentArtifactComponents.findMany({
         where: and(
           eq(subAgentArtifactComponents.tenantId, tenantId),
-          eq(subAgentArtifactComponents.subAgentId, agent.id)
+          eq(subAgentArtifactComponents.subAgentId, agent2.id)
         )
       });
       const agentArtifactComponentIds = agentArtifactComponentRelations.map(
@@ -216304,12 +216291,12 @@ var getFullGraphDefinition = (db) => async ({
       }));
       const canUse = [...mcpToolCanUse, ...functionToolCanUse];
       return {
-        id: agent.id,
-        name: agent.name,
-        description: agent.description,
-        prompt: agent.prompt,
-        models: agent.models,
-        stopWhen: agent.stopWhen,
+        id: agent2.id,
+        name: agent2.name,
+        description: agent2.description,
+        prompt: agent2.prompt,
+        models: agent2.models,
+        stopWhen: agent2.stopWhen,
         canTransferTo,
         canDelegateTo,
         dataComponents: agentDataComponentIds,
@@ -216321,54 +216308,48 @@ var getFullGraphDefinition = (db) => async ({
   const externalAgents2 = await Promise.all(
     Array.from(externalSubAgentIds).map(async (subAgentId) => {
       const subAgent = await getExternalAgent(db)({
-        scopes: { tenantId, projectId, graphId },
+        scopes: { tenantId, projectId, agentId },
         subAgentId
       });
       if (!subAgent) return null;
       return {
-        id: subAgent.id,
-        name: subAgent.name,
-        description: subAgent.description,
-        baseUrl: subAgent.baseUrl,
-        headers: subAgent.headers,
-        credentialReferenceId: subAgent.credentialReferenceId,
+        ...subAgent,
         type: "external"
       };
     })
   );
-  const validAgents = [...processedSubAgents, ...externalAgents2].filter(
-    (agent) => agent !== null
+  const validSubAgents = [...processedSubAgents, ...externalAgents2].filter(
+    (agent2) => agent2 !== null
   );
   const agentsObject = {};
-  for (const agent of validAgents) {
-    const isExternalAgent2 = "baseUrl" in agent && agent.baseUrl;
-    if (isExternalAgent2) {
-      agentsObject[agent.id] = {
-        id: agent.id,
-        name: agent.name,
-        description: agent.description,
-        baseUrl: agent.baseUrl,
-        credentialReferenceId: agent.credentialReferenceId,
-        headers: agent.headers,
+  for (const subAgent of validSubAgents) {
+    if ("baseUrl" in subAgent && subAgent.baseUrl) {
+      agentsObject[subAgent.id] = {
+        id: subAgent.id,
+        name: subAgent.name,
+        description: subAgent.description,
+        baseUrl: subAgent.baseUrl,
+        credentialReferenceId: subAgent.credentialReferenceId,
+        headers: subAgent.headers,
         type: "external"
       };
     } else {
-      agentsObject[agent.id] = agent;
+      agentsObject[subAgent.id] = subAgent;
     }
   }
   let contextConfig2 = null;
-  if (graph.contextConfigId) {
+  if (agent.contextConfigId) {
     try {
       contextConfig2 = await getContextConfigById(db)({
-        scopes: { tenantId, projectId, graphId },
-        id: graph.contextConfigId
+        scopes: { tenantId, projectId, agentId },
+        id: agent.contextConfigId
       });
     } catch (error) {
-      console.warn(`Failed to retrieve contextConfig ${graph.contextConfigId}:`, error);
+      console.warn(`Failed to retrieve contextConfig ${agent.contextConfigId}:`, error);
     }
   }
   try {
-    const internalAgentIds = graphSubAgents.map((agent) => agent.id);
+    const internalAgentIds = agentSubAgents.map((subAgent) => subAgent.id);
     const subAgentIds = Array.from(internalAgentIds);
     await fetchComponentRelationships(db)({ tenantId, projectId }, subAgentIds, {
       relationTable: subAgentDataComponents,
@@ -216387,7 +216368,7 @@ var getFullGraphDefinition = (db) => async ({
     console.warn("Failed to retrieve dataComponents:", error);
   }
   try {
-    const internalAgentIds = graphSubAgents.map((agent) => agent.id);
+    const internalAgentIds = agentSubAgents.map((subAgent) => subAgent.id);
     const subAgentIds = Array.from(internalAgentIds);
     await fetchComponentRelationships(db)({ tenantId, projectId }, subAgentIds, {
       relationTable: subAgentArtifactComponents,
@@ -216406,33 +216387,29 @@ var getFullGraphDefinition = (db) => async ({
     console.warn("Failed to retrieve artifactComponents:", error);
   }
   const result = {
-    id: graph.id,
-    name: graph.name,
-    description: graph.description,
-    defaultSubAgentId: graph.defaultSubAgentId,
+    id: agent.id,
+    name: agent.name,
+    description: agent.description,
+    defaultSubAgentId: agent.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()
+    createdAt: agent.createdAt && !Number.isNaN(new Date(agent.createdAt).getTime()) ? new Date(agent.createdAt).toISOString() : (/* @__PURE__ */ new Date()).toISOString(),
+    updatedAt: agent.updatedAt && !Number.isNaN(new Date(agent.updatedAt).getTime()) ? new Date(agent.updatedAt).toISOString() : (/* @__PURE__ */ new Date()).toISOString()
   };
-  if (graph.models) {
-    result.models = graph.models;
+  if (agent.models) {
+    result.models = agent.models;
   }
-  if (graph.statusUpdates) {
-    result.statusUpdates = graph.statusUpdates;
+  if (agent.statusUpdates) {
+    result.statusUpdates = agent.statusUpdates;
   }
-  if (graph.graphPrompt) {
-    result.graphPrompt = graph.graphPrompt;
+  if (agent.prompt) {
+    result.prompt = agent.prompt;
   }
-  if (graph.stopWhen) {
-    result.stopWhen = graph.stopWhen;
+  if (agent.stopWhen) {
+    result.stopWhen = agent.stopWhen;
   }
   if (contextConfig2) {
-    result.contextConfig = {
-      id: contextConfig2.id,
-      headersSchema: contextConfig2.headersSchema,
-      contextVariables: contextConfig2.contextVariables
-    };
+    const { id, headersSchema, contextVariables } = contextConfig2;
+    result.contextConfig = { id, headersSchema, contextVariables };
   }
   try {
     if (!db.query?.projects?.findFirst) {
@@ -216443,33 +216420,36 @@ var getFullGraphDefinition = (db) => async ({
     });
     if (project?.stopWhen) {
       const projectStopWhen = project.stopWhen;
-      if (projectStopWhen?.stepCountIs !== void 0) {
-        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;
-            if (needsInheritance) {
-              if (!agent.stopWhen) {
-                agent.stopWhen = {};
-              }
-              agent.stopWhen.stepCountIs = projectStopWhen.stepCountIs;
-              try {
-                await db.update(subAgents).set({
-                  stopWhen: agent.stopWhen,
-                  updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-                }).where(
-                  and(
-                    eq(subAgents.tenantId, tenantId),
-                    eq(subAgents.projectId, projectId),
-                    eq(subAgents.id, subAgentId)
-                  )
-                );
-                result.subAgents[subAgentId] = {
-                  ...result.subAgents[subAgentId],
-                  stopWhen: agent.stopWhen
-                };
-              } catch (dbError) {
-                console.warn(`Failed to persist stopWhen for agent ${subAgentId}:`, dbError);
+      if (projectStopWhen.stepCountIs !== void 0) {
+        const resultSubAgents = result.subAgents;
+        if (resultSubAgents) {
+          for (const [subAgentId, agentData] of Object.entries(resultSubAgents)) {
+            if (agentData && typeof agentData === "object" && !("baseUrl" in agentData)) {
+              const agent2 = agentData;
+              const needsInheritance = !agent2.stopWhen || agent2.stopWhen.stepCountIs === void 0;
+              if (needsInheritance) {
+                if (!agent2.stopWhen) {
+                  agent2.stopWhen = {};
+                }
+                agent2.stopWhen.stepCountIs = projectStopWhen.stepCountIs;
+                try {
+                  await db.update(subAgents).set({
+                    stopWhen: agent2.stopWhen,
+                    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+                  }).where(
+                    and(
+                      eq(subAgents.tenantId, tenantId),
+                      eq(subAgents.projectId, projectId),
+                      eq(subAgents.id, subAgentId)
+                    )
+                  );
+                  result.subAgents[subAgentId] = {
+                    ...result.subAgents[subAgentId],
+                    stopWhen: agent2.stopWhen
+                  };
+                } catch (dbError) {
+                  console.warn(`Failed to persist stopWhen for agent ${subAgentId}:`, dbError);
+                }
               }
             }
           }
@@ -216497,7 +216477,7 @@ var getFullGraphDefinition = (db) => async ({
     }
     result.tools = toolsObject;
     const functionToolsList = await listFunctionTools(db)({
-      scopes: { tenantId, projectId, graphId },
+      scopes: { tenantId, projectId, agentId },
       pagination: { page: 1, limit: 1e3 }
     });
     const functionToolsObject = {};
@@ -216517,36 +216497,38 @@ var getFullGraphDefinition = (db) => async ({
       }
     }
     if (functionIds.size > 0) {
-      const functionsObject = {};
-      for (const functionId of functionIds) {
-        const func = await getFunction(db)({
-          functionId,
-          scopes: { tenantId, projectId }
-        });
-        if (func) {
-          functionsObject[functionId] = {
-            id: func.id,
-            inputSchema: func.inputSchema,
-            executeCode: func.executeCode,
-            dependencies: func.dependencies
-          };
-        }
-      }
-      result.functions = functionsObject;
+      const functions2 = (await Promise.all(
+        Array.from(functionIds).map(async (functionId) => {
+          const func = await getFunction(db)({
+            functionId,
+            scopes: { tenantId, projectId }
+          });
+          return func ? [
+            functionId,
+            {
+              id: func.id,
+              inputSchema: func.inputSchema,
+              executeCode: func.executeCode,
+              dependencies: func.dependencies
+            }
+          ] : null;
+        })
+      )).filter((entry) => entry !== null);
+      result.functions = Object.fromEntries(functions2);
     }
   } catch (error) {
     console.warn("Failed to load tools/functions lookups:", error);
   }
   return result;
 };
-var upsertAgentGraph = (db) => async (params) => {
-  const graphId = params.data.id || nanoid();
-  const scopes = { tenantId: params.data.tenantId, projectId: params.data.projectId, graphId };
-  const existing = await getAgentGraphById(db)({
+var upsertAgent = (db) => async (params) => {
+  const agentId = params.data.id || nanoid();
+  const scopes = { tenantId: params.data.tenantId, projectId: params.data.projectId, agentId };
+  const existing = await getAgentById(db)({
     scopes
   });
   if (existing) {
-    return await updateAgentGraph(db)({
+    return await updateAgent(db)({
       scopes,
       data: {
         name: params.data.name,
@@ -216557,12 +216539,11 @@ var upsertAgentGraph = (db) => async (params) => {
         statusUpdates: params.data.statusUpdates
       }
     });
-  } else {
-    return await createAgentGraph(db)({
-      ...params.data,
-      id: graphId
-    });
   }
+  return await createAgent(db)({
+    ...params.data,
+    id: agentId
+  });
 };
 var getApiKeyById = (db) => async (params) => {
   return await db.query.apiKeys.findFirst({
@@ -216583,8 +216564,8 @@ var listApiKeys = (db) => async (params) => {
     eq(apiKeys.tenantId, params.scopes.tenantId),
     eq(apiKeys.projectId, params.scopes.projectId)
   ];
-  if (params.graphId) {
-    conditions.push(eq(apiKeys.graphId, params.graphId));
+  if (params.agentId) {
+    conditions.push(eq(apiKeys.agentId, params.agentId));
   }
   return await db.query.apiKeys.findMany({
     where: and(...conditions),
@@ -216599,8 +216580,8 @@ var listApiKeysPaginated = (db) => async (params) => {
     eq(apiKeys.tenantId, params.scopes.tenantId),
     eq(apiKeys.projectId, params.scopes.projectId)
   ];
-  if (params.graphId) {
-    conditions.push(eq(apiKeys.graphId, params.graphId));
+  if (params.agentId) {
+    conditions.push(eq(apiKeys.agentId, params.agentId));
   }
   const whereClause = and(...conditions);
   const [data, totalResult] = await Promise.all([
@@ -216622,7 +216603,7 @@ var createApiKey = (db) => async (params) => {
     name: params.name,
     tenantId: params.tenantId,
     projectId: params.projectId,
-    graphId: params.graphId,
+    agentId: params.agentId,
     publicId: params.publicId,
     keyHash: params.keyHash,
     keyPrefix: params.keyPrefix,
@@ -216681,20 +216662,20 @@ var countApiKeys = (db) => async (params) => {
     eq(apiKeys.tenantId, params.scopes.tenantId),
     eq(apiKeys.projectId, params.scopes.projectId)
   ];
-  if (params.graphId) {
-    conditions.push(eq(apiKeys.graphId, params.graphId));
+  if (params.agentId) {
+    conditions.push(eq(apiKeys.agentId, params.agentId));
   }
   const result = await db.select({ count: count() }).from(apiKeys).where(and(...conditions));
   const total = result[0]?.count || 0;
   return typeof total === "string" ? Number.parseInt(total, 10) : total;
 };
 var generateAndCreateApiKey = async (params, db) => {
-  const { tenantId, projectId, graphId, expiresAt, name } = params;
+  const { tenantId, projectId, agentId, expiresAt, name } = params;
   const keyData = await generateApiKey();
   const apiKey = await createApiKey(db)({
     tenantId,
     projectId,
-    graphId,
+    agentId,
     name,
     expiresAt,
     ...keyData
@@ -216834,7 +216815,7 @@ var getArtifactComponentsForAgent = (db) => async (params) => {
     and(
       eq(artifactComponents.tenantId, params.scopes.tenantId),
       eq(artifactComponents.projectId, params.scopes.projectId),
-      eq(subAgentArtifactComponents.graphId, params.scopes.graphId),
+      eq(subAgentArtifactComponents.agentId, params.scopes.agentId),
       eq(subAgentArtifactComponents.subAgentId, params.scopes.subAgentId)
     )
   ).orderBy(desc(artifactComponents.createdAt));
@@ -216844,7 +216825,7 @@ var associateArtifactComponentWithAgent = (db) => async (params) => {
     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()
@@ -216857,7 +216838,7 @@ var removeArtifactComponentFromAgent = (db) => async (params) => {
       and(
         eq(subAgentArtifactComponents.tenantId, params.scopes.tenantId),
         eq(subAgentArtifactComponents.projectId, params.scopes.projectId),
-        eq(subAgentArtifactComponents.graphId, params.scopes.graphId),
+        eq(subAgentArtifactComponents.agentId, params.scopes.agentId),
         eq(subAgentArtifactComponents.subAgentId, params.scopes.subAgentId),
         eq(subAgentArtifactComponents.artifactComponentId, params.artifactComponentId)
       )
@@ -216872,7 +216853,7 @@ var deleteAgentArtifactComponentRelationByAgent = (db) => async (params) => {
   const result = await db.delete(subAgentArtifactComponents).where(
     and(
       eq(subAgentArtifactComponents.tenantId, params.scopes.tenantId),
-      eq(subAgentArtifactComponents.graphId, params.scopes.graphId),
+      eq(subAgentArtifactComponents.agentId, params.scopes.agentId),
       eq(subAgentArtifactComponents.subAgentId, params.scopes.subAgentId)
     )
   );
@@ -216880,7 +216861,7 @@ var deleteAgentArtifactComponentRelationByAgent = (db) => async (params) => {
 };
 var getAgentsUsingArtifactComponent = (db) => async (params) => {
   return await db.select({
-    graphId: subAgentArtifactComponents.graphId,
+    agentId: subAgentArtifactComponents.agentId,
     subAgentId: subAgentArtifactComponents.subAgentId,
     createdAt: subAgentArtifactComponents.createdAt
   }).from(subAgentArtifactComponents).where(
@@ -216896,14 +216877,14 @@ var isArtifactComponentAssociatedWithAgent = (db) => async (params) => {
     and(
       eq(subAgentArtifactComponents.tenantId, params.scopes.tenantId),
       eq(subAgentArtifactComponents.projectId, params.scopes.projectId),
-      eq(subAgentArtifactComponents.graphId, params.scopes.graphId),
+      eq(subAgentArtifactComponents.agentId, params.scopes.agentId),
       eq(subAgentArtifactComponents.subAgentId, params.scopes.subAgentId),
       eq(subAgentArtifactComponents.artifactComponentId, params.artifactComponentId)
     )
   ).limit(1);
   return result.length > 0;
 };
-var graphHasArtifactComponents = (db) => async (params) => {
+var agentHasArtifactComponents = (db) => async (params) => {
   const result = await db.select({ count: count() }).from(subAgentArtifactComponents).innerJoin(
     subAgents,
     and(
@@ -216916,13 +216897,13 @@ var graphHasArtifactComponents = (db) => async (params) => {
       eq(subAgents.id, subAgentRelations.sourceSubAgentId),
       eq(subAgents.tenantId, subAgentRelations.tenantId),
       eq(subAgents.projectId, subAgentRelations.projectId),
-      eq(subAgents.graphId, subAgentRelations.graphId)
+      eq(subAgents.agentId, subAgentRelations.agentId)
     )
   ).where(
     and(
       eq(subAgentArtifactComponents.tenantId, params.scopes.tenantId),
       eq(subAgentArtifactComponents.projectId, params.scopes.projectId),
-      eq(subAgentRelations.graphId, params.scopes.graphId)
+      eq(subAgentRelations.agentId, params.scopes.agentId)
     )
   ).limit(1);
   const total = result[0]?.count || 0;
@@ -216944,7 +216925,7 @@ var countArtifactComponentsForAgent = (db) => async (params) => {
     and(
       eq(subAgentArtifactComponents.tenantId, params.scopes.tenantId),
       eq(subAgentArtifactComponents.projectId, params.scopes.projectId),
-      eq(subAgentArtifactComponents.graphId, params.scopes.graphId),
+      eq(subAgentArtifactComponents.agentId, params.scopes.agentId),
       eq(subAgentArtifactComponents.subAgentId, params.scopes.subAgentId)
     )
   );
@@ -217428,7 +217409,7 @@ var getDataComponentsForAgent = (db) => async (params) => {
     and(
       eq(dataComponents.tenantId, params.scopes.tenantId),
       eq(dataComponents.projectId, params.scopes.projectId),
-      eq(subAgentDataComponents.graphId, params.scopes.graphId),
+      eq(subAgentDataComponents.agentId, params.scopes.agentId),
       eq(subAgentDataComponents.subAgentId, params.scopes.subAgentId)
     )
   ).orderBy(desc(dataComponents.createdAt));
@@ -217438,7 +217419,7 @@ var associateDataComponentWithAgent = (db) => async (params) => {
     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();
@@ -217449,7 +217430,7 @@ var removeDataComponentFromAgent = (db) => async (params) => {
     and(
       eq(subAgentDataComponents.tenantId, params.scopes.tenantId),
       eq(subAgentDataComponents.projectId, params.scopes.projectId),
-      eq(subAgentDataComponents.graphId, params.scopes.graphId),
+      eq(subAgentDataComponents.agentId, params.scopes.agentId),
       eq(subAgentDataComponents.subAgentId, params.scopes.subAgentId),
       eq(subAgentDataComponents.dataComponentId, params.dataComponentId)
     )
@@ -217460,7 +217441,7 @@ var deleteAgentDataComponentRelationByAgent = (db) => async (params) => {
   const result = await db.delete(subAgentDataComponents).where(
     and(
       eq(subAgentDataComponents.tenantId, params.scopes.tenantId),
-      eq(subAgentDataComponents.graphId, params.scopes.graphId),
+      eq(subAgentDataComponents.agentId, params.scopes.agentId),
       eq(subAgentDataComponents.subAgentId, params.scopes.subAgentId)
     )
   );
@@ -217483,7 +217464,7 @@ var isDataComponentAssociatedWithAgent = (db) => async (params) => {
     and(
       eq(subAgentDataComponents.tenantId, params.scopes.tenantId),
       eq(subAgentDataComponents.projectId, params.scopes.projectId),
-      eq(subAgentDataComponents.graphId, params.scopes.graphId),
+      eq(subAgentDataComponents.agentId, params.scopes.agentId),
       eq(subAgentDataComponents.subAgentId, params.scopes.subAgentId),
       eq(subAgentDataComponents.dataComponentId, params.dataComponentId)
     )
@@ -217533,7 +217514,7 @@ var defaultLogger = {
   error: () => {
   }
 };
-async function applyExecutionLimitsInheritance(db, logger13, scopes, graphData) {
+async function applyExecutionLimitsInheritance(db, logger13, scopes, agentData) {
   const { tenantId, projectId } = scopes;
   try {
     const project = await db.query.projects.findFirst({
@@ -217551,27 +217532,27 @@ async function applyExecutionLimitsInheritance(db, logger13, scopes, graphData)
       },
       "Found project stopWhen configuration"
     );
-    if (!graphData.stopWhen) {
-      graphData.stopWhen = {};
+    if (!agentData.stopWhen) {
+      agentData.stopWhen = {};
     }
-    if (graphData.stopWhen.transferCountIs === void 0 && projectStopWhen?.transferCountIs !== void 0) {
-      graphData.stopWhen.transferCountIs = projectStopWhen.transferCountIs;
+    if (agentData.stopWhen.transferCountIs === void 0 && projectStopWhen?.transferCountIs !== void 0) {
+      agentData.stopWhen.transferCountIs = projectStopWhen.transferCountIs;
       logger13.info(
         {
-          graphId: graphData.id,
+          agentId: agentData.id,
           inheritedValue: projectStopWhen.transferCountIs
         },
-        "Graph inherited transferCountIs from project"
+        "Agent inherited transferCountIs from project"
       );
     }
-    if (graphData.stopWhen.transferCountIs === void 0) {
-      graphData.stopWhen.transferCountIs = 10;
+    if (agentData.stopWhen.transferCountIs === void 0) {
+      agentData.stopWhen.transferCountIs = 10;
       logger13.info(
         {
-          graphId: graphData.id,
+          agentId: agentData.id,
           defaultValue: 10
         },
-        "Graph set to default transferCountIs"
+        "Agent set to default transferCountIs"
       );
     }
     if (projectStopWhen?.stepCountIs !== void 0) {
@@ -217582,8 +217563,8 @@ async function applyExecutionLimitsInheritance(db, logger13, scopes, graphData)
         },
         "Propagating stepCountIs to agents"
       );
-      for (const [subAgentId, agentData] of Object.entries(graphData.subAgents)) {
-        if (isInternalAgent(agentData)) {
+      for (const [subAgentId, subAgentData] of Object.entries(agentData.subAgents)) {
+        if (isInternalAgent(subAgentData)) {
           const agent = agentData;
           if (!agent.stopWhen) {
             agent.stopWhen = {};
@@ -217611,24 +217592,24 @@ async function applyExecutionLimitsInheritance(db, logger13, scopes, graphData)
     );
   }
 }
-var createFullGraphServerSide = (db, logger13 = defaultLogger) => async (scopes, graphData) => {
+var createFullAgentServerSide = (db, logger13 = defaultLogger) => async (scopes, agentData) => {
   const { tenantId, projectId } = scopes;
-  const typed = validateAndTypeGraphData(graphData);
-  validateGraphStructure(typed);
+  const typed = validateAndTypeAgentData(agentData);
+  validateAgentStructure(typed);
   await applyExecutionLimitsInheritance(db, logger13, { tenantId, projectId }, typed);
   try {
     logger13.info(
       {},
-      "CredentialReferences are project-scoped - skipping credential reference creation in graph"
+      "CredentialReferences are project-scoped - skipping credential reference creation in agent"
     );
-    logger13.info({}, "MCP Tools are project-scoped - skipping tool creation in graph");
-    let finalGraphId;
+    logger13.info({}, "MCP Tools are project-scoped - skipping tool creation in agent");
+    let finalAgentId;
     try {
-      const graphId = typed.id || nanoid();
-      logger13.info({ graphId }, "Creating agent graph metadata");
-      const agentGraph2 = await upsertAgentGraph(db)({
+      const agentId = typed.id || nanoid();
+      logger13.info({ agentId }, "Creating agent agent metadata");
+      const agent = await upsertAgent(db)({
         data: {
-          id: graphId,
+          id: agentId,
           tenantId,
           projectId,
           name: typed.name,
@@ -217638,14 +217619,17 @@ var createFullGraphServerSide = (db, logger13 = defaultLogger) => async (scopes,
           // Will be updated later if context config exists
           models: typed.models,
           statusUpdates: typed.statusUpdates,
-          graphPrompt: typed.graphPrompt,
+          prompt: typed.prompt,
           stopWhen: typed.stopWhen
         }
       });
-      finalGraphId = agentGraph2.id;
-      logger13.info({ graphId: finalGraphId }, "Agent graph metadata created successfully");
+      if (!agent?.id) {
+        throw new Error("Failed to create agent: no ID returned");
+      }
+      finalAgentId = agent.id;
+      logger13.info({ agentId: finalAgentId }, "Agent agent metadata created successfully");
     } catch (error) {
-      logger13.error({ graphId: typed.id, error }, "Failed to create/update graph metadata");
+      logger13.error({ agentId: typed.id, error }, "Failed to create/update agent metadata");
       throw error;
     }
     let contextConfigId;
@@ -217655,7 +217639,7 @@ var createFullGraphServerSide = (db, logger13 = defaultLogger) => async (scopes,
         const contextConfig2 = await upsertContextConfig(db)({
           data: {
             ...typed.contextConfig,
-            graphId: finalGraphId,
+            agentId: finalAgentId,
             tenantId,
             projectId
           }
@@ -217673,12 +217657,12 @@ var createFullGraphServerSide = (db, logger13 = defaultLogger) => async (scopes,
     if (contextConfigId) {
       try {
         logger13.info(
-          { graphId: finalGraphId, contextConfigId },
-          "Updating graph with contextConfigId"
+          { agentId: finalAgentId, contextConfigId },
+          "Updating agent with contextConfigId"
         );
-        await upsertAgentGraph(db)({
+        await upsertAgent(db)({
           data: {
-            id: finalGraphId,
+            id: finalAgentId,
             tenantId,
             projectId,
             name: typed.name,
@@ -217687,42 +217671,42 @@ var createFullGraphServerSide = (db, logger13 = defaultLogger) => async (scopes,
             contextConfigId,
             models: typed.models,
             statusUpdates: typed.statusUpdates,
-            graphPrompt: typed.graphPrompt,
+            prompt: typed.prompt,
             stopWhen: typed.stopWhen
           }
         });
         logger13.info(
-          { graphId: finalGraphId, contextConfigId },
-          "Graph updated with contextConfigId successfully"
+          { agentId: finalAgentId, contextConfigId },
+          "Agent updated with contextConfigId successfully"
         );
       } catch (error) {
         logger13.error(
-          { graphId: finalGraphId, contextConfigId, error },
-          "Failed to update graph with contextConfigId"
+          { agentId: finalAgentId, contextConfigId, error },
+          "Failed to update agent with contextConfigId"
         );
         throw error;
       }
     }
     logger13.info(
       {},
-      "DataComponents are project-scoped - skipping dataComponent creation in graph"
+      "DataComponents are project-scoped - skipping dataComponent creation in agent"
     );
     logger13.info(
       {},
-      "ArtifactComponents are project-scoped - skipping artifactComponent creation in graph"
+      "ArtifactComponents are project-scoped - skipping artifactComponent creation in agent"
     );
     if (typed.functions && Object.keys(typed.functions).length > 0) {
       logger13.info(
         {
-          graphId: finalGraphId,
+          agentId: finalAgentId,
           functionCount: Object.keys(typed.functions).length
         },
-        "Creating functions for graph"
+        "Creating functions for agent"
       );
       const functionPromises = Object.entries(typed.functions).map(
         async ([functionId, functionData]) => {
           try {
-            logger13.info({ graphId: finalGraphId, functionId }, "Creating function for graph");
+            logger13.info({ agentId: finalAgentId, functionId }, "Creating function for agent");
             await upsertFunction(db)({
               data: {
                 ...functionData,
@@ -217730,11 +217714,11 @@ var createFullGraphServerSide = (db, logger13 = defaultLogger) => async (scopes,
               },
               scopes: { tenantId, projectId }
             });
-            logger13.info({ graphId: finalGraphId, functionId }, "Function created successfully");
+            logger13.info({ agentId: finalAgentId, functionId }, "Function created successfully");
           } catch (error) {
             logger13.error(
-              { graphId: finalGraphId, functionId, error },
-              "Failed to create function for graph"
+              { agentId: finalAgentId, functionId, error },
+              "Failed to create function for agent"
             );
             throw error;
           }
@@ -217743,7 +217727,7 @@ var createFullGraphServerSide = (db, logger13 = defaultLogger) => async (scopes,
       await Promise.all(functionPromises);
       logger13.info(
         {
-          graphId: finalGraphId,
+          agentId: finalAgentId,
           functionCount: Object.keys(typed.functions).length
         },
         "All functions created successfully"
@@ -217752,33 +217736,33 @@ var createFullGraphServerSide = (db, logger13 = defaultLogger) => async (scopes,
     if (typed.functionTools && Object.keys(typed.functionTools).length > 0) {
       logger13.info(
         {
-          graphId: finalGraphId,
+          agentId: finalAgentId,
           functionToolCount: Object.keys(typed.functionTools).length
         },
-        "Creating function tools for graph"
+        "Creating function tools for agent"
       );
       const functionToolPromises = Object.entries(typed.functionTools).map(
         async ([functionToolId, functionToolData]) => {
           try {
             logger13.info(
-              { graphId: finalGraphId, functionToolId },
-              "Creating function tool in graph"
+              { agentId: finalAgentId, functionToolId },
+              "Creating function tool in agent"
             );
             await upsertFunctionTool(db)({
               data: {
                 ...functionToolData,
                 id: functionToolId
               },
-              scopes: { tenantId, projectId, graphId: finalGraphId }
+              scopes: { tenantId, projectId, agentId: finalAgentId }
             });
             logger13.info(
-              { graphId: finalGraphId, functionToolId },
+              { agentId: finalAgentId, functionToolId },
               "Function tool created successfully"
             );
           } catch (error) {
             logger13.error(
-              { graphId: finalGraphId, functionToolId, error },
-              "Failed to create function tool in graph"
+              { agentId: finalAgentId, functionToolId, error },
+              "Failed to create function tool in agent"
             );
             throw error;
           }
@@ -217787,14 +217771,14 @@ var createFullGraphServerSide = (db, logger13 = defaultLogger) => async (scopes,
       await Promise.all(functionToolPromises);
       logger13.info(
         {
-          graphId: finalGraphId,
+          agentId: finalAgentId,
           functionToolCount: Object.keys(typed.functionTools).length
         },
         "All function tools created successfully"
       );
     }
-    const internalAgentPromises = Object.entries(typed.subAgents).filter(([_, agentData]) => isInternalAgent(agentData)).map(async ([subAgentId, agentData]) => {
-      const internalAgent = agentData;
+    const internalAgentPromises = Object.entries(typed.subAgents).filter(([_, agentData2]) => isInternalAgent(agentData2)).map(async ([subAgentId, agentData2]) => {
+      const internalAgent = agentData2;
       try {
         logger13.info({ subAgentId }, "Processing internal agent");
         await upsertSubAgent(db)({
@@ -217802,7 +217786,7 @@ var createFullGraphServerSide = (db, logger13 = defaultLogger) => async (scopes,
             id: subAgentId,
             tenantId,
             projectId,
-            graphId: finalGraphId,
+            agentId: finalAgentId,
             name: internalAgent.name || "",
             description: internalAgent.description || "",
             prompt: internalAgent.prompt || "",
@@ -217819,11 +217803,11 @@ var createFullGraphServerSide = (db, logger13 = defaultLogger) => async (scopes,
     });
     await Promise.all(internalAgentPromises);
     const internalAgentCount = Object.entries(typed.subAgents).filter(
-      ([_, agentData]) => isInternalAgent(agentData)
+      ([_, agentData2]) => isInternalAgent(agentData2)
     ).length;
     logger13.info({ internalAgentCount }, "All internal agents created/updated successfully");
-    const externalAgentPromises = Object.entries(typed.subAgents).filter(([_, agentData]) => isExternalAgent(agentData)).map(async ([subAgentId, agentData]) => {
-      const externalAgent = agentData;
+    const externalAgentPromises = Object.entries(typed.subAgents).filter(([_, agentData2]) => isExternalAgent(agentData2)).map(async ([subAgentId, agentData2]) => {
+      const externalAgent = agentData2;
       try {
         logger13.info({ subAgentId }, "Processing external agent");
         await upsertExternalAgent(db)({
@@ -217831,7 +217815,7 @@ var createFullGraphServerSide = (db, logger13 = defaultLogger) => async (scopes,
             id: subAgentId,
             tenantId,
             projectId,
-            graphId: finalGraphId,
+            agentId: finalAgentId,
             name: externalAgent.name,
             description: externalAgent.description || "",
             baseUrl: externalAgent.baseUrl,
@@ -217847,32 +217831,32 @@ var createFullGraphServerSide = (db, logger13 = defaultLogger) => async (scopes,
     });
     await Promise.all(externalAgentPromises);
     const externalAgentCount = Object.entries(typed.subAgents).filter(
-      ([_, agentData]) => isExternalAgent(agentData)
+      ([_, agentData2]) => isExternalAgent(agentData2)
     ).length;
     logger13.info({ externalAgentCount }, "All external agents created/updated successfully");
     if (contextConfigId) {
       try {
         logger13.info(
-          { graphId: finalGraphId, contextConfigId },
-          "Updating graph with context config"
+          { agentId: finalAgentId, contextConfigId },
+          "Updating agent with context config"
         );
-        await updateAgentGraph(db)({
-          scopes: { tenantId, projectId, graphId: finalGraphId },
+        await updateAgent(db)({
+          scopes: { tenantId, projectId, agentId: finalAgentId },
           data: { contextConfigId }
         });
-        logger13.info({ graphId: finalGraphId }, "Graph updated with context config");
+        logger13.info({ agentId: finalAgentId }, "Agent updated with context config");
       } catch (error) {
         logger13.error(
-          { graphId: finalGraphId, error },
-          "Failed to update graph with context config"
+          { agentId: finalAgentId, error },
+          "Failed to update agent with context config"
         );
         throw error;
       }
     }
     const agentToolPromises = [];
-    for (const [subAgentId, agentData] of Object.entries(typed.subAgents)) {
-      if (isInternalAgent(agentData) && agentData.canUse && Array.isArray(agentData.canUse)) {
-        for (const canUseItem of agentData.canUse) {
+    for (const [subAgentId, agentData2] of Object.entries(typed.subAgents)) {
+      if (isInternalAgent(agentData2) && agentData2.canUse && Array.isArray(agentData2.canUse)) {
+        for (const canUseItem of agentData2.canUse) {
           agentToolPromises.push(
             (async () => {
               try {
@@ -217891,7 +217875,7 @@ var createFullGraphServerSide = (db, logger13 = defaultLogger) => async (scopes,
                 if (isFunctionTool) {
                   logger13.info({ subAgentId, toolId }, "Processing agent-function tool relation");
                   await upsertSubAgentFunctionToolRelation(db)({
-                    scopes: { tenantId, projectId, graphId: finalGraphId },
+                    scopes: { tenantId, projectId, agentId: finalAgentId },
                     subAgentId,
                     functionToolId: toolId,
                     relationId: agentToolRelationId
@@ -217903,7 +217887,7 @@ var createFullGraphServerSide = (db, logger13 = defaultLogger) => async (scopes,
                 } else {
                   logger13.info({ subAgentId, toolId }, "Processing agent-MCP tool relation");
                   await upsertSubAgentToolRelation(db)({
-                    scopes: { tenantId, projectId, graphId: finalGraphId },
+                    scopes: { tenantId, projectId, agentId: finalAgentId },
                     subAgentId,
                     toolId,
                     selectedTools: toolSelection || void 0,
@@ -217932,9 +217916,9 @@ var createFullGraphServerSide = (db, logger13 = defaultLogger) => async (scopes,
       "All agent-tool relations created"
     );
     const agentDataComponentPromises = [];
-    for (const [subAgentId, agentData] of Object.entries(typed.subAgents)) {
-      if (isInternalAgent(agentData) && agentData.dataComponents) {
-        for (const dataComponentId of agentData.dataComponents) {
+    for (const [subAgentId, agentData2] of Object.entries(typed.subAgents)) {
+      if (isInternalAgent(agentData2) && agentData2.dataComponents) {
+        for (const dataComponentId of agentData2.dataComponents) {
           agentDataComponentPromises.push(
             (async () => {
               try {
@@ -217943,7 +217927,7 @@ var createFullGraphServerSide = (db, logger13 = defaultLogger) => async (scopes,
                   "Processing agent-data component relation"
                 );
                 await upsertAgentDataComponentRelation(db)({
-                  scopes: { tenantId, projectId, graphId: finalGraphId, subAgentId },
+                  scopes: { tenantId, projectId, agentId: finalAgentId, subAgentId },
                   dataComponentId
                 });
                 logger13.info(
@@ -217964,9 +217948,9 @@ var createFullGraphServerSide = (db, logger13 = defaultLogger) => async (scopes,
     await Promise.all(agentDataComponentPromises);
     logger13.info({}, "All agent-data component relations created");
     const agentArtifactComponentPromises = [];
-    for (const [subAgentId, agentData] of Object.entries(typed.subAgents)) {
-      if (isInternalAgent(agentData) && agentData.artifactComponents) {
-        for (const artifactComponentId of agentData.artifactComponents) {
+    for (const [subAgentId, agentData2] of Object.entries(typed.subAgents)) {
+      if (isInternalAgent(agentData2) && agentData2.artifactComponents) {
+        for (const artifactComponentId of agentData2.artifactComponents) {
           agentArtifactComponentPromises.push(
             (async () => {
               try {
@@ -217975,7 +217959,7 @@ var createFullGraphServerSide = (db, logger13 = defaultLogger) => async (scopes,
                   "Processing agent-artifact component relation"
                 );
                 await upsertAgentArtifactComponentRelation(db)({
-                  scopes: { tenantId, projectId, graphId: finalGraphId, subAgentId },
+                  scopes: { tenantId, projectId, agentId: finalAgentId, subAgentId },
                   artifactComponentId
                 });
                 logger13.info(
@@ -217996,9 +217980,9 @@ var createFullGraphServerSide = (db, logger13 = defaultLogger) => async (scopes,
     await Promise.all(agentArtifactComponentPromises);
     logger13.info({}, "All agent-artifact component relations created");
     const agentRelationPromises = [];
-    for (const [subAgentId, agentData] of Object.entries(typed.subAgents)) {
-      if (isInternalAgent(agentData) && agentData.canTransferTo) {
-        for (const targetSubAgentId of agentData.canTransferTo) {
+    for (const [subAgentId, agentData2] of Object.entries(typed.subAgents)) {
+      if (isInternalAgent(agentData2) && agentData2.canTransferTo) {
+        for (const targetSubAgentId of agentData2.canTransferTo) {
           agentRelationPromises.push(
             (async () => {
               try {
@@ -218010,7 +217994,7 @@ var createFullGraphServerSide = (db, logger13 = defaultLogger) => async (scopes,
                   id: nanoid(),
                   tenantId,
                   projectId,
-                  graphId: finalGraphId,
+                  agentId: finalAgentId,
                   sourceSubAgentId: subAgentId,
                   targetSubAgentId,
                   relationType: "transfer"
@@ -218029,8 +218013,8 @@ var createFullGraphServerSide = (db, logger13 = defaultLogger) => async (scopes,
           );
         }
       }
-      if (isInternalAgent(agentData) && agentData.canDelegateTo) {
-        for (const targetSubAgentId of agentData.canDelegateTo) {
+      if (isInternalAgent(agentData2) && agentData2.canDelegateTo) {
+        for (const targetSubAgentId of agentData2.canDelegateTo) {
           const targetAgentData = typed.subAgents[targetSubAgentId];
           const isTargetExternal = isExternalAgent(targetAgentData);
           agentRelationPromises.push(
@@ -218044,7 +218028,7 @@ var createFullGraphServerSide = (db, logger13 = defaultLogger) => async (scopes,
                   id: nanoid(),
                   tenantId,
                   projectId,
-                  graphId: finalGraphId,
+                  agentId: finalAgentId,
                   sourceSubAgentId: subAgentId,
                   targetSubAgentId: isTargetExternal ? void 0 : targetSubAgentId,
                   externalSubAgentId: isTargetExternal ? targetSubAgentId : void 0,
@@ -218070,100 +218054,103 @@ var createFullGraphServerSide = (db, logger13 = defaultLogger) => async (scopes,
       { agentRelationCount: agentRelationPromises.length },
       "All agent relations created"
     );
-    const createdGraph = await getFullGraphDefinition(db)({
-      scopes: { tenantId, projectId, graphId: finalGraphId }
+    const createdAgent = await getFullAgentDefinition(db)({
+      scopes: { tenantId, projectId, agentId: finalAgentId }
     });
-    if (!createdGraph) {
-      throw new Error("Failed to retrieve created graph");
+    if (!createdAgent) {
+      throw new Error("Failed to retrieve created agent");
     }
-    logger13.info({ tenantId, graphId: finalGraphId }, "Full graph created successfully");
-    return createdGraph;
+    logger13.info({ tenantId, agentId: finalAgentId }, "Full agent created successfully");
+    return createdAgent;
   } catch (error) {
-    const errorGraphId = typed.id || "unknown";
-    logger13.error({ tenantId, graphId: errorGraphId, error }, "Failed to create full graph");
+    const errorAgentId = typed.id || "unknown";
+    logger13.error({ tenantId, agentId: errorAgentId, error }, "Failed to create full agent");
     throw error;
   }
 };
-var updateFullGraphServerSide = (db, logger13 = defaultLogger) => async (scopes, graphData) => {
+var updateFullAgentServerSide = (db, logger13 = defaultLogger) => async (scopes, agentData) => {
   const { tenantId, projectId } = scopes;
-  const typedGraphDefinition = validateAndTypeGraphData(graphData);
-  if (!typedGraphDefinition.id) {
-    throw new Error("Graph ID is required");
+  const typedAgentDefinition = validateAndTypeAgentData(agentData);
+  if (!typedAgentDefinition.id) {
+    throw new Error("Agent ID is required");
   }
   logger13.info(
     {
       tenantId,
-      graphId: typedGraphDefinition.id,
-      agentCount: Object.keys(typedGraphDefinition.subAgents).length
+      agentId: typedAgentDefinition.id,
+      agentCount: Object.keys(typedAgentDefinition.subAgents).length
     },
-    "Updating full graph in database"
+    "Updating full agent in database"
   );
-  validateGraphStructure(typedGraphDefinition);
+  validateAgentStructure(typedAgentDefinition);
   await applyExecutionLimitsInheritance(
     db,
     logger13,
     { tenantId, projectId },
-    typedGraphDefinition
+    typedAgentDefinition
   );
   try {
-    const existingGraph = await getAgentGraphById(db)({
-      scopes: { tenantId, projectId, graphId: typedGraphDefinition.id }
+    const existingAgent = await getAgentById(db)({
+      scopes: { tenantId, projectId, agentId: typedAgentDefinition.id }
     });
-    if (!existingGraph) {
+    if (!existingAgent) {
       logger13.info(
-        { graphId: typedGraphDefinition.id },
-        "Graph does not exist, creating new graph"
+        { agentId: typedAgentDefinition.id },
+        "Agent does not exist, creating new agent"
       );
-      return createFullGraphServerSide(db, logger13)(scopes, graphData);
+      return createFullAgentServerSide(db, logger13)(scopes, agentData);
     }
-    const existingGraphModels = existingGraph.models;
+    const existingAgentModels = existingAgent.models;
     logger13.info(
       {},
-      "CredentialReferences are project-scoped - skipping credential reference update in graph"
+      "CredentialReferences are project-scoped - skipping credential reference update in agent"
     );
-    logger13.info({}, "MCP Tools are project-scoped - skipping tool creation in graph update");
-    let finalGraphId;
+    logger13.info({}, "MCP Tools are project-scoped - skipping tool creation in agent update");
+    let finalAgentId;
     try {
-      const graphId = typedGraphDefinition.id || nanoid();
-      logger13.info({ graphId }, "Getting/creating agent graph metadata");
-      const agentGraph2 = await upsertAgentGraph(db)({
+      const agentId = typedAgentDefinition.id || nanoid();
+      logger13.info({ agentId }, "Getting/creating agent metadata");
+      const agent = await upsertAgent(db)({
         data: {
-          id: graphId,
+          id: agentId,
           tenantId,
           projectId,
-          name: typedGraphDefinition.name,
-          defaultSubAgentId: typedGraphDefinition.defaultSubAgentId,
-          description: typedGraphDefinition.description,
+          name: typedAgentDefinition.name,
+          defaultSubAgentId: typedAgentDefinition.defaultSubAgentId,
+          description: typedAgentDefinition.description,
           contextConfigId: void 0,
           // Will be updated later if context config exists
-          models: typedGraphDefinition.models,
-          statusUpdates: typedGraphDefinition.statusUpdates,
-          graphPrompt: typedGraphDefinition.graphPrompt,
-          stopWhen: typedGraphDefinition.stopWhen
+          models: typedAgentDefinition.models,
+          statusUpdates: typedAgentDefinition.statusUpdates,
+          prompt: typedAgentDefinition.prompt,
+          stopWhen: typedAgentDefinition.stopWhen
         }
       });
-      finalGraphId = agentGraph2.id;
-      logger13.info({ graphId: finalGraphId }, "Agent graph metadata ready");
+      if (!agent?.id) {
+        throw new Error("Failed to upsert agent: no ID returned");
+      }
+      finalAgentId = agent.id;
+      logger13.info({ agentId: finalAgentId }, "Agent agent metadata ready");
     } catch (error) {
       logger13.error(
-        { graphId: typedGraphDefinition.id, error },
-        "Failed to get/update graph metadata"
+        { agentId: typedAgentDefinition.id, error },
+        "Failed to get/update agent metadata"
       );
       throw error;
     }
     let contextConfigId;
-    if (typedGraphDefinition.contextConfig) {
+    if (typedAgentDefinition.contextConfig) {
       logger13.info(
-        { contextConfigId: typedGraphDefinition.contextConfig?.id },
+        { contextConfigId: typedAgentDefinition.contextConfig?.id },
         " context config exists"
       );
     }
-    if (typedGraphDefinition.contextConfig) {
+    if (typedAgentDefinition.contextConfig) {
       try {
         const contextConfig2 = await upsertContextConfig(db)({
           data: {
-            ...typedGraphDefinition.contextConfig,
-            graphId: finalGraphId,
+            ...typedAgentDefinition.contextConfig,
+            agentId: finalAgentId,
             tenantId,
             projectId
           }
@@ -218172,7 +218159,7 @@ var updateFullGraphServerSide = (db, logger13 = defaultLogger) => async (scopes,
         logger13.info({ contextConfigId }, "Context config processed successfully");
       } catch (error) {
         logger13.error(
-          { contextConfigId: typedGraphDefinition.contextConfig.id, error },
+          { contextConfigId: typedAgentDefinition.contextConfig.id, error },
           "Failed to create/update context config"
         );
         throw error;
@@ -218181,53 +218168,53 @@ var updateFullGraphServerSide = (db, logger13 = defaultLogger) => async (scopes,
     if (contextConfigId) {
       try {
         logger13.info(
-          { graphId: finalGraphId, contextConfigId },
-          "Updating graph with contextConfigId"
+          { agentId: finalAgentId, contextConfigId },
+          "Updating agent with contextConfigId"
         );
-        await upsertAgentGraph(db)({
+        await upsertAgent(db)({
           data: {
-            id: finalGraphId,
+            id: finalAgentId,
             tenantId,
             projectId,
-            name: typedGraphDefinition.name,
-            defaultSubAgentId: typedGraphDefinition.defaultSubAgentId,
-            description: typedGraphDefinition.description,
+            name: typedAgentDefinition.name,
+            defaultSubAgentId: typedAgentDefinition.defaultSubAgentId,
+            description: typedAgentDefinition.description,
             contextConfigId,
-            models: typedGraphDefinition.models,
-            statusUpdates: typedGraphDefinition.statusUpdates,
-            graphPrompt: typedGraphDefinition.graphPrompt,
-            stopWhen: typedGraphDefinition.stopWhen
+            models: typedAgentDefinition.models,
+            statusUpdates: typedAgentDefinition.statusUpdates,
+            prompt: typedAgentDefinition.prompt,
+            stopWhen: typedAgentDefinition.stopWhen
           }
         });
         logger13.info(
-          { graphId: finalGraphId, contextConfigId },
-          "Graph updated with contextConfigId successfully"
+          { agentId: finalAgentId, contextConfigId },
+          "Agent updated with contextConfigId successfully"
         );
       } catch (error) {
         logger13.error(
-          { graphId: finalGraphId, contextConfigId, error },
-          "Failed to update graph with contextConfigId"
+          { agentId: finalAgentId, contextConfigId, error },
+          "Failed to update agent with contextConfigId"
         );
         throw error;
       }
     }
-    logger13.info({}, "DataComponents are project-scoped - skipping dataComponent update in graph");
+    logger13.info({}, "DataComponents are project-scoped - skipping dataComponent update in agent");
     logger13.info(
       {},
-      "ArtifactComponents are project-scoped - skipping artifactComponent update in graph"
+      "ArtifactComponents are project-scoped - skipping artifactComponent update in agent"
     );
-    if (typedGraphDefinition.functions && Object.keys(typedGraphDefinition.functions).length > 0) {
+    if (typedAgentDefinition.functions && Object.keys(typedAgentDefinition.functions).length > 0) {
       logger13.info(
         {
-          graphId: finalGraphId,
-          functionCount: Object.keys(typedGraphDefinition.functions).length
+          agentId: finalAgentId,
+          functionCount: Object.keys(typedAgentDefinition.functions).length
         },
-        "Updating functions for graph"
+        "Updating functions for agent"
       );
-      const functionPromises = Object.entries(typedGraphDefinition.functions).map(
+      const functionPromises = Object.entries(typedAgentDefinition.functions).map(
         async ([functionId, functionData]) => {
           try {
-            logger13.info({ graphId: finalGraphId, functionId }, "Updating function for graph");
+            logger13.info({ agentId: finalAgentId, functionId }, "Updating function for agent");
             await upsertFunction(db)({
               data: {
                 ...functionData,
@@ -218235,11 +218222,11 @@ var updateFullGraphServerSide = (db, logger13 = defaultLogger) => async (scopes,
               },
               scopes: { tenantId, projectId }
             });
-            logger13.info({ graphId: finalGraphId, functionId }, "Function updated successfully");
+            logger13.info({ agentId: finalAgentId, functionId }, "Function updated successfully");
           } catch (error) {
             logger13.error(
-              { graphId: finalGraphId, functionId, error },
-              "Failed to update function for graph"
+              { agentId: finalAgentId, functionId, error },
+              "Failed to update function for agent"
             );
             throw error;
           }
@@ -218248,42 +218235,42 @@ var updateFullGraphServerSide = (db, logger13 = defaultLogger) => async (scopes,
       await Promise.all(functionPromises);
       logger13.info(
         {
-          graphId: finalGraphId,
-          functionCount: Object.keys(typedGraphDefinition.functions).length
+          agentId: finalAgentId,
+          functionCount: Object.keys(typedAgentDefinition.functions).length
         },
         "All functions updated successfully"
       );
     }
-    if (typedGraphDefinition.functionTools && Object.keys(typedGraphDefinition.functionTools).length > 0) {
+    if (typedAgentDefinition.functionTools && Object.keys(typedAgentDefinition.functionTools).length > 0) {
       logger13.info(
         {
-          graphId: finalGraphId,
-          functionToolCount: Object.keys(typedGraphDefinition.functionTools).length
+          agentId: finalAgentId,
+          functionToolCount: Object.keys(typedAgentDefinition.functionTools).length
         },
-        "Updating function tools for graph"
+        "Updating function tools for agent"
       );
-      const functionToolPromises = Object.entries(typedGraphDefinition.functionTools).map(
+      const functionToolPromises = Object.entries(typedAgentDefinition.functionTools).map(
         async ([functionToolId, functionToolData]) => {
           try {
             logger13.info(
-              { graphId: finalGraphId, functionToolId },
-              "Updating function tool in graph"
+              { agentId: finalAgentId, functionToolId },
+              "Updating function tool in agent"
             );
             await upsertFunctionTool(db)({
               data: {
                 ...functionToolData,
                 id: functionToolId
               },
-              scopes: { tenantId, projectId, graphId: finalGraphId }
+              scopes: { tenantId, projectId, agentId: finalAgentId }
             });
             logger13.info(
-              { graphId: finalGraphId, functionToolId },
+              { agentId: finalAgentId, functionToolId },
               "Function tool updated successfully"
             );
           } catch (error) {
             logger13.error(
-              { graphId: finalGraphId, functionToolId, error },
-              "Failed to update function tool in graph"
+              { agentId: finalAgentId, functionToolId, error },
+              "Failed to update function tool in agent"
             );
             throw error;
           }
@@ -218292,17 +218279,17 @@ var updateFullGraphServerSide = (db, logger13 = defaultLogger) => async (scopes,
       await Promise.all(functionToolPromises);
       logger13.info(
         {
-          graphId: finalGraphId,
-          functionToolCount: Object.keys(typedGraphDefinition.functionTools).length
+          agentId: finalAgentId,
+          functionToolCount: Object.keys(typedAgentDefinition.functionTools).length
         },
         "All function tools updated successfully"
       );
     }
-    const internalAgentPromises = Object.entries(typedGraphDefinition.subAgents).filter(([_, agentData]) => isInternalAgent(agentData)).map(async ([subAgentId, agentData]) => {
-      const internalAgent = agentData;
-      let existingAgent = null;
+    const internalAgentPromises = Object.entries(typedAgentDefinition.subAgents).filter(([_, agentData2]) => isInternalAgent(agentData2)).map(async ([subAgentId, agentData2]) => {
+      const internalAgent = agentData2;
+      let existingSubAgent = null;
       try {
-        existingAgent = await db.query.subAgents.findFirst({
+        existingSubAgent = await db.query.subAgents.findFirst({
           where: and(
             eq(subAgents.id, subAgentId),
             eq(subAgents.tenantId, tenantId),
@@ -218315,25 +218302,25 @@ var updateFullGraphServerSide = (db, logger13 = defaultLogger) => async (scopes,
       } catch (_error) {
       }
       let finalModelSettings = internalAgent.models === void 0 ? void 0 : internalAgent.models;
-      if (existingAgent?.models && typedGraphDefinition.models) {
-        const agentModels = existingAgent.models;
-        const graphModels = typedGraphDefinition.models;
+      if (existingSubAgent?.models && typedAgentDefinition.models) {
+        const subAgentModels = existingSubAgent.models;
+        const agentModels = typedAgentDefinition.models;
         const modelTypes = ["base", "structuredOutput", "summarizer"];
         const cascadedModels = { ...finalModelSettings };
         for (const modelType of modelTypes) {
-          if (agentModels[modelType]?.model && existingGraphModels?.[modelType]?.model && agentModels[modelType].model === existingGraphModels[modelType].model && graphModels[modelType] && // Model name changed
-          (graphModels[modelType].model !== existingGraphModels[modelType].model || // OR providerOptions changed
-          JSON.stringify(graphModels[modelType].providerOptions) !== JSON.stringify(existingGraphModels[modelType].providerOptions))) {
-            cascadedModels[modelType] = graphModels[modelType];
+          if (subAgentModels[modelType]?.model && existingAgentModels?.[modelType]?.model && subAgentModels[modelType].model === existingAgentModels[modelType].model && agentModels[modelType] && // Model name changed
+          (agentModels[modelType].model !== existingAgentModels[modelType]?.model || // OR providerOptions changed
+          JSON.stringify(agentModels[modelType].providerOptions) !== JSON.stringify(existingAgentModels[modelType]?.providerOptions))) {
+            cascadedModels[modelType] = agentModels[modelType];
             logger13.info(
               {
                 subAgentId,
                 modelType,
-                oldModel: agentModels[modelType].model,
-                newModel: graphModels[modelType].model,
-                hasProviderOptions: !!graphModels[modelType].providerOptions
+                oldModel: existingAgentModels[modelType]?.model,
+                newModel: agentModels[modelType].model,
+                hasProviderOptions: !!agentModels[modelType].providerOptions
               },
-              "Cascading model change from graph to agent"
+              "Cascading model change from parent agent to subAgent"
             );
           }
         }
@@ -218346,7 +218333,7 @@ var updateFullGraphServerSide = (db, logger13 = defaultLogger) => async (scopes,
             id: subAgentId,
             tenantId,
             projectId,
-            graphId: finalGraphId,
+            agentId: finalAgentId,
             name: internalAgent.name || "",
             description: internalAgent.description || "",
             prompt: internalAgent.prompt || "",
@@ -218362,12 +218349,12 @@ var updateFullGraphServerSide = (db, logger13 = defaultLogger) => async (scopes,
       }
     });
     await Promise.all(internalAgentPromises);
-    const internalAgentCount = Object.entries(typedGraphDefinition.subAgents).filter(
-      ([_, agentData]) => isInternalAgent(agentData)
+    const internalAgentCount = Object.entries(typedAgentDefinition.subAgents).filter(
+      ([_, agentData2]) => isInternalAgent(agentData2)
     ).length;
     logger13.info({ internalAgentCount }, "All internal agents created/updated successfully");
-    const externalAgentPromises = Object.entries(typedGraphDefinition.subAgents).filter(([_, agentData]) => isExternalAgent(agentData)).map(async ([subAgentId, agentData]) => {
-      const externalAgent = agentData;
+    const externalAgentPromises = Object.entries(typedAgentDefinition.subAgents).filter(([_, agentData2]) => isExternalAgent(agentData2)).map(async ([subAgentId, agentData2]) => {
+      const externalAgent = agentData2;
       try {
         logger13.info({ subAgentId }, "Processing external agent");
         await upsertExternalAgent(db)({
@@ -218375,7 +218362,7 @@ var updateFullGraphServerSide = (db, logger13 = defaultLogger) => async (scopes,
             id: subAgentId,
             tenantId,
             projectId,
-            graphId: finalGraphId,
+            agentId: finalAgentId,
             name: externalAgent.name,
             description: externalAgent.description || "",
             baseUrl: externalAgent.baseUrl,
@@ -218390,23 +218377,23 @@ var updateFullGraphServerSide = (db, logger13 = defaultLogger) => async (scopes,
       }
     });
     await Promise.all(externalAgentPromises);
-    const externalAgentCount = Object.entries(typedGraphDefinition.subAgents).filter(
-      ([_, agentData]) => isExternalAgent(agentData)
+    const externalAgentCount = Object.entries(typedAgentDefinition.subAgents).filter(
+      ([_, agentData2]) => isExternalAgent(agentData2)
     ).length;
     logger13.info({ externalAgentCount }, "All external agents created/updated successfully");
-    const incomingAgentIds = new Set(Object.keys(typedGraphDefinition.subAgents));
+    const incomingAgentIds = new Set(Object.keys(typedAgentDefinition.subAgents));
     const existingInternalAgents = await listSubAgents(db)({
-      scopes: { tenantId, projectId, graphId: finalGraphId }
+      scopes: { tenantId, projectId, agentId: finalAgentId }
     });
     const existingExternalAgents = await listExternalAgents(db)({
-      scopes: { tenantId, projectId, graphId: finalGraphId }
+      scopes: { tenantId, projectId, agentId: finalAgentId }
     });
     let deletedInternalCount = 0;
     for (const agent of existingInternalAgents) {
       if (!incomingAgentIds.has(agent.id)) {
         try {
           await deleteSubAgent(db)({
-            scopes: { tenantId, projectId, graphId: finalGraphId },
+            scopes: { tenantId, projectId, agentId: finalAgentId },
             subAgentId: agent.id
           });
           deletedInternalCount++;
@@ -218424,7 +218411,7 @@ var updateFullGraphServerSide = (db, logger13 = defaultLogger) => async (scopes,
       if (!incomingAgentIds.has(agent.id)) {
         try {
           await deleteExternalAgent(db)({
-            scopes: { tenantId, projectId, graphId: finalGraphId },
+            scopes: { tenantId, projectId, agentId: finalAgentId },
             subAgentId: agent.id
           });
           deletedExternalCount++;
@@ -218444,34 +218431,34 @@ var updateFullGraphServerSide = (db, logger13 = defaultLogger) => async (scopes,
           deletedExternalCount,
           totalDeleted: deletedInternalCount + deletedExternalCount
         },
-        "Deleted orphaned agents from graph"
+        "Deleted orphaned agents from agent"
       );
     }
-    await updateAgentGraph(db)({
-      scopes: { tenantId, projectId, graphId: typedGraphDefinition.id },
+    await updateAgent(db)({
+      scopes: { tenantId, projectId, agentId: typedAgentDefinition.id },
       data: {
-        name: typedGraphDefinition.name,
-        defaultSubAgentId: typedGraphDefinition.defaultSubAgentId,
-        description: typedGraphDefinition.description,
+        name: typedAgentDefinition.name,
+        defaultSubAgentId: typedAgentDefinition.defaultSubAgentId,
+        description: typedAgentDefinition.description,
         contextConfigId,
-        models: typedGraphDefinition.models,
-        statusUpdates: typedGraphDefinition.statusUpdates,
-        graphPrompt: typedGraphDefinition.graphPrompt,
-        stopWhen: typedGraphDefinition.stopWhen
+        models: typedAgentDefinition.models,
+        statusUpdates: typedAgentDefinition.statusUpdates,
+        prompt: typedAgentDefinition.prompt,
+        stopWhen: typedAgentDefinition.stopWhen
       }
     });
-    logger13.info({ graphId: typedGraphDefinition.id }, "Graph metadata updated");
+    logger13.info({ agentId: typedAgentDefinition.id }, "Agent metadata updated");
     const incomingRelationshipIds = /* @__PURE__ */ new Set();
-    for (const [_subAgentId, agentData] of Object.entries(typedGraphDefinition.subAgents)) {
-      if (isInternalAgent(agentData) && agentData.canUse && Array.isArray(agentData.canUse)) {
-        for (const canUseItem of agentData.canUse) {
+    for (const [_subAgentId, agentData2] of Object.entries(typedAgentDefinition.subAgents)) {
+      if (isInternalAgent(agentData2) && agentData2.canUse && Array.isArray(agentData2.canUse)) {
+        for (const canUseItem of agentData2.canUse) {
           if (canUseItem.agentToolRelationId) {
             incomingRelationshipIds.add(canUseItem.agentToolRelationId);
           }
         }
       }
     }
-    for (const subAgentId of Object.keys(typedGraphDefinition.subAgents)) {
+    for (const subAgentId of Object.keys(typedAgentDefinition.subAgents)) {
       try {
         let deletedCount = 0;
         if (incomingRelationshipIds.size === 0) {
@@ -218479,7 +218466,7 @@ var updateFullGraphServerSide = (db, logger13 = defaultLogger) => async (scopes,
             and(
               eq(subAgentToolRelations.tenantId, tenantId),
               eq(subAgentToolRelations.projectId, projectId),
-              eq(subAgentToolRelations.graphId, finalGraphId),
+              eq(subAgentToolRelations.agentId, finalAgentId),
               eq(subAgentToolRelations.subAgentId, subAgentId)
             )
           );
@@ -218489,7 +218476,7 @@ var updateFullGraphServerSide = (db, logger13 = defaultLogger) => async (scopes,
             and(
               eq(subAgentToolRelations.tenantId, tenantId),
               eq(subAgentToolRelations.projectId, projectId),
-              eq(subAgentToolRelations.graphId, finalGraphId),
+              eq(subAgentToolRelations.agentId, finalAgentId),
               eq(subAgentToolRelations.subAgentId, subAgentId),
               not(inArray(subAgentToolRelations.id, Array.from(incomingRelationshipIds)))
             )
@@ -218504,18 +218491,18 @@ var updateFullGraphServerSide = (db, logger13 = defaultLogger) => async (scopes,
       }
     }
     const agentToolPromises = [];
-    for (const [subAgentId, agentData] of Object.entries(typedGraphDefinition.subAgents)) {
-      if (isInternalAgent(agentData) && agentData.canUse && Array.isArray(agentData.canUse)) {
-        for (const canUseItem of agentData.canUse) {
+    for (const [subAgentId, agentData2] of Object.entries(typedAgentDefinition.subAgents)) {
+      if (isInternalAgent(agentData2) && agentData2.canUse && Array.isArray(agentData2.canUse)) {
+        for (const canUseItem of agentData2.canUse) {
           agentToolPromises.push(
             (async () => {
               try {
                 const { toolId, toolSelection, headers: headers2, agentToolRelationId } = canUseItem;
-                const isFunctionTool = typedGraphDefinition.functionTools && toolId in typedGraphDefinition.functionTools;
+                const isFunctionTool = typedAgentDefinition.functionTools && toolId in typedAgentDefinition.functionTools;
                 if (isFunctionTool) {
                   logger13.info({ subAgentId, toolId }, "Processing agent-function tool relation");
                   await upsertSubAgentFunctionToolRelation(db)({
-                    scopes: { tenantId, projectId, graphId: finalGraphId },
+                    scopes: { tenantId, projectId, agentId: finalAgentId },
                     subAgentId,
                     functionToolId: toolId,
                     relationId: agentToolRelationId
@@ -218527,7 +218514,7 @@ var updateFullGraphServerSide = (db, logger13 = defaultLogger) => async (scopes,
                 } else {
                   logger13.info({ subAgentId, toolId }, "Processing agent-MCP tool relation");
                   await upsertSubAgentToolRelation(db)({
-                    scopes: { tenantId, projectId, graphId: finalGraphId },
+                    scopes: { tenantId, projectId, agentId: finalAgentId },
                     subAgentId,
                     toolId,
                     selectedTools: toolSelection || void 0,
@@ -218560,20 +218547,20 @@ var updateFullGraphServerSide = (db, logger13 = defaultLogger) => async (scopes,
       { agentToolPromisesCount: agentToolPromises.length },
       "All agent-tool relations updated"
     );
-    for (const subAgentId of Object.keys(typedGraphDefinition.subAgents)) {
+    for (const subAgentId of Object.keys(typedAgentDefinition.subAgents)) {
       await deleteAgentDataComponentRelationByAgent(db)({
-        scopes: { tenantId, projectId, graphId: finalGraphId, subAgentId }
+        scopes: { tenantId, projectId, agentId: finalAgentId, subAgentId }
       });
     }
     const agentDataComponentPromises = [];
-    for (const [subAgentId, agentData] of Object.entries(typedGraphDefinition.subAgents)) {
-      if (isInternalAgent(agentData) && agentData.dataComponents) {
-        for (const dataComponentId of agentData.dataComponents) {
+    for (const [subAgentId, agentData2] of Object.entries(typedAgentDefinition.subAgents)) {
+      if (isInternalAgent(agentData2) && agentData2.dataComponents) {
+        for (const dataComponentId of agentData2.dataComponents) {
           agentDataComponentPromises.push(
             (async () => {
               try {
                 await associateDataComponentWithAgent(db)({
-                  scopes: { tenantId, projectId, graphId: finalGraphId, subAgentId },
+                  scopes: { tenantId, projectId, agentId: finalAgentId, subAgentId },
                   dataComponentId
                 });
                 logger13.info(
@@ -218596,20 +218583,20 @@ var updateFullGraphServerSide = (db, logger13 = defaultLogger) => async (scopes,
       { agentDataComponentPromisesCount: agentDataComponentPromises.length },
       "All agent-dataComponent relations updated"
     );
-    for (const subAgentId of Object.keys(typedGraphDefinition.subAgents)) {
+    for (const subAgentId of Object.keys(typedAgentDefinition.subAgents)) {
       await deleteAgentArtifactComponentRelationByAgent(db)({
-        scopes: { tenantId, projectId, graphId: finalGraphId, subAgentId }
+        scopes: { tenantId, projectId, agentId: finalAgentId, subAgentId }
       });
     }
     const agentArtifactComponentPromises = [];
-    for (const [subAgentId, agentData] of Object.entries(typedGraphDefinition.subAgents)) {
-      if (isInternalAgent(agentData) && agentData.artifactComponents) {
-        for (const artifactComponentId of agentData.artifactComponents) {
+    for (const [subAgentId, agentData2] of Object.entries(typedAgentDefinition.subAgents)) {
+      if (isInternalAgent(agentData2) && agentData2.artifactComponents) {
+        for (const artifactComponentId of agentData2.artifactComponents) {
           agentArtifactComponentPromises.push(
             (async () => {
               try {
                 await associateArtifactComponentWithAgent(db)({
-                  scopes: { tenantId, projectId, graphId: finalGraphId, subAgentId },
+                  scopes: { tenantId, projectId, agentId: finalAgentId, subAgentId },
                   artifactComponentId
                 });
                 logger13.info(
@@ -218632,22 +218619,22 @@ var updateFullGraphServerSide = (db, logger13 = defaultLogger) => async (scopes,
       { agentArtifactComponentPromisesCount: agentArtifactComponentPromises.length },
       "All agent-artifactComponent relations updated"
     );
-    await deleteAgentRelationsByGraph(db)({
-      scopes: { tenantId, projectId, graphId: typedGraphDefinition.id }
+    await deleteAgentRelationsByAgent(db)({
+      scopes: { tenantId, projectId, agentId: typedAgentDefinition.id }
     });
     const agentRelationPromises = [];
-    for (const [subAgentId, agentData] of Object.entries(typedGraphDefinition.subAgents)) {
-      if (isInternalAgent(agentData) && agentData.canTransferTo) {
-        for (const targetSubAgentId of agentData.canTransferTo) {
+    for (const [subAgentId, agentData2] of Object.entries(typedAgentDefinition.subAgents)) {
+      if (isInternalAgent(agentData2) && agentData2.canTransferTo) {
+        for (const targetSubAgentId of agentData2.canTransferTo) {
           agentRelationPromises.push(
             (async () => {
               try {
-                const targetAgentData = typedGraphDefinition.subAgents[targetSubAgentId];
+                const targetAgentData = typedAgentDefinition.subAgents[targetSubAgentId];
                 const isTargetExternal = isExternalAgent(targetAgentData);
                 const targetField = isTargetExternal ? "externalSubAgentId" : "targetSubAgentId";
                 const relationData = {
                   id: nanoid(),
-                  graphId: typedGraphDefinition.id || "",
+                  agentId: typedAgentDefinition.id || "",
                   sourceSubAgentId: subAgentId,
                   relationType: "transfer",
                   [targetField]: targetSubAgentId
@@ -218671,9 +218658,9 @@ var updateFullGraphServerSide = (db, logger13 = defaultLogger) => async (scopes,
           );
         }
       }
-      if (isInternalAgent(agentData) && agentData.canDelegateTo) {
-        for (const targetSubAgentId of agentData.canDelegateTo) {
-          const targetAgentData = typedGraphDefinition.subAgents[targetSubAgentId];
+      if (isInternalAgent(agentData2) && agentData2.canDelegateTo) {
+        for (const targetSubAgentId of agentData2.canDelegateTo) {
+          const targetAgentData = typedAgentDefinition.subAgents[targetSubAgentId];
           const isTargetExternal = isExternalAgent(targetAgentData);
           const targetField = isTargetExternal ? "externalSubAgentId" : "targetSubAgentId";
           agentRelationPromises.push(
@@ -218681,7 +218668,7 @@ var updateFullGraphServerSide = (db, logger13 = defaultLogger) => async (scopes,
               try {
                 const relationData = {
                   id: nanoid(),
-                  graphId: typedGraphDefinition.id || "",
+                  agentId: typedAgentDefinition.id || "",
                   sourceSubAgentId: subAgentId,
                   relationType: "delegate",
                   [targetField]: targetSubAgentId
@@ -218708,93 +218695,93 @@ var updateFullGraphServerSide = (db, logger13 = defaultLogger) => async (scopes,
       { agentRelationPromisesCount: agentRelationPromises.length },
       "All agent relations updated"
     );
-    const updatedGraph = await getFullGraphDefinition(db)({
-      scopes: { tenantId, projectId, graphId: typedGraphDefinition.id }
+    const updatedAgent = await getFullAgentDefinition(db)({
+      scopes: { tenantId, projectId, agentId: typedAgentDefinition.id }
     });
-    if (!updatedGraph) {
-      throw new Error("Failed to retrieve updated graph");
+    if (!updatedAgent) {
+      throw new Error("Failed to retrieve updated agent");
     }
-    logger13.info({ graphId: typedGraphDefinition.id }, "Full graph updated successfully");
-    return updatedGraph;
+    logger13.info({ agentId: typedAgentDefinition.id }, "Full agent updated successfully");
+    return updatedAgent;
   } catch (error) {
-    logger13.error({ graphId: typedGraphDefinition.id, error }, "Failed to update full graph");
+    logger13.error({ agentId: typedAgentDefinition.id, error }, "Failed to update full agent");
     throw error;
   }
 };
-var getFullGraph = (db, logger13 = defaultLogger) => async (params) => {
+var getFullAgent = (db, logger13 = defaultLogger) => async (params) => {
   const { scopes } = params;
   const { tenantId, projectId } = scopes;
-  logger13.info({ tenantId, graphId: scopes.graphId }, "Retrieving full graph definition");
+  logger13.info({ tenantId, agentId: scopes.agentId }, "Retrieving full agent definition");
   try {
-    const graph = await getFullGraphDefinition(db)({
-      scopes: { tenantId, projectId, graphId: scopes.graphId }
+    const agent = await getFullAgentDefinition(db)({
+      scopes: { tenantId, projectId, agentId: scopes.agentId }
     });
-    if (!graph) {
-      logger13.info({ tenantId, graphId: scopes.graphId }, "Graph not found");
+    if (!agent) {
+      logger13.info({ tenantId, agentId: scopes.agentId }, "Agent not found");
       return null;
     }
     logger13.info(
       {
         tenantId,
-        graphId: scopes.graphId,
-        agentCount: Object.keys(graph.subAgents).length
+        agentId: scopes.agentId,
+        agentCount: Object.keys(agent.subAgents).length
       },
-      "Full graph retrieved successfully"
+      "Full agent retrieved successfully"
     );
-    return graph;
+    return agent;
   } catch (error) {
     logger13.error(
       {
         tenantId,
-        graphId: scopes.graphId,
+        agentId: scopes.agentId,
         error: error instanceof Error ? error.message : "Unknown error"
       },
-      "Failed to retrieve full graph"
+      "Failed to retrieve full agent"
     );
     throw error;
   }
 };
-var deleteFullGraph = (db, logger13 = defaultLogger) => async (params) => {
-  const { tenantId, projectId, graphId } = params.scopes;
-  logger13.info({ tenantId, graphId }, "Deleting full graph and related entities");
+var deleteFullAgent = (db, logger13 = defaultLogger) => async (params) => {
+  const { tenantId, projectId, agentId } = params.scopes;
+  logger13.info({ tenantId, agentId }, "Deleting full agent and related entities");
   try {
-    const graph = await getFullGraphDefinition(db)({
-      scopes: { tenantId, projectId, graphId }
+    const agent = await getFullAgentDefinition(db)({
+      scopes: { tenantId, projectId, agentId }
     });
-    if (!graph) {
-      logger13.info({ tenantId, graphId }, "Graph not found for deletion");
+    if (!agent) {
+      logger13.info({ tenantId, agentId }, "Agent not found for deletion");
       return false;
     }
-    await deleteAgentRelationsByGraph(db)({
-      scopes: { tenantId, projectId, graphId }
+    await deleteAgentRelationsByAgent(db)({
+      scopes: { tenantId, projectId, agentId }
     });
-    logger13.info({ tenantId, graphId }, "Agent relations deleted");
-    const subAgentIds = Object.keys(graph.subAgents);
+    logger13.info({ tenantId, agentId }, "Agent relations deleted");
+    const subAgentIds = Object.keys(agent.subAgents);
     if (subAgentIds.length > 0) {
       for (const subAgentId of subAgentIds) {
         await deleteAgentToolRelationByAgent(db)({
-          scopes: { tenantId, projectId, graphId, subAgentId }
+          scopes: { tenantId, projectId, agentId, subAgentId }
         });
       }
       logger13.info(
-        { tenantId, graphId, agentCount: subAgentIds.length },
+        { tenantId, agentId, agentCount: subAgentIds.length },
         "Agent-tool relations deleted"
       );
     }
-    await deleteAgentGraph(db)({
-      scopes: { tenantId, projectId, graphId }
+    await deleteAgent(db)({
+      scopes: { tenantId, projectId, agentId }
     });
-    logger13.info({ tenantId, graphId }, "Graph metadata deleted");
-    logger13.info({ tenantId, graphId }, "Full graph deleted successfully");
+    logger13.info({ tenantId, agentId }, "Agent metadata deleted");
+    logger13.info({ tenantId, agentId }, "Full agent deleted successfully");
     return true;
   } catch (error) {
     logger13.error(
       {
         tenantId,
-        graphId,
+        agentId,
         error: error instanceof Error ? error.message : "Unknown error"
       },
-      "Failed to delete full graph"
+      "Failed to delete full agent"
     );
     throw error;
   }
@@ -219177,7 +219164,7 @@ var listProjects = (db) => async (params) => {
   }
   const projectIdSets = await Promise.all([
     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: agents.projectId }).from(agents).where(eq(agents.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)),
@@ -219223,16 +219210,16 @@ 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([
+  const [subAgentResults, agentResults, toolResults, contextConfigResults, externalAgentResults] = await Promise.all([
     db.select({ count: subAgents.id }).from(subAgents).where(whereClause(subAgents)),
-    db.select({ count: agentGraph.id }).from(agentGraph).where(whereClause(agentGraph)),
+    db.select({ count: agents.id }).from(agents).where(whereClause(agents)),
     db.select({ count: tools.id }).from(tools).where(whereClause(tools)),
     db.select({ count: contextConfigs.id }).from(contextConfigs).where(whereClause(contextConfigs)),
     db.select({ count: externalAgents.id }).from(externalAgents).where(whereClause(externalAgents))
   ]);
   return {
+    subAgents: subAgentResults.length,
     agents: agentResults.length,
-    agentGraphs: graphResults.length,
     tools: toolResults.length,
     contextConfigs: contextConfigResults.length,
     externalAgents: externalAgentResults.length
@@ -219242,7 +219229,7 @@ var projectExists = (db) => async (params) => {
   const whereClause = (table) => and(eq(table.tenantId, params.tenantId), eq(table.projectId, params.projectId));
   const checks = [
     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: agents.id }).from(agents).where(whereClause(agents)).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),
     db.select({ id: externalAgents.id }).from(externalAgents).where(whereClause(externalAgents)).limit(1),
@@ -219324,24 +219311,24 @@ var deleteProject = (db) => async (params) => {
 async function cascadeStopWhenUpdates(db, scopes, oldStopWhen, newStopWhen) {
   const { tenantId, projectId } = scopes;
   if (oldStopWhen?.transferCountIs !== newStopWhen?.transferCountIs) {
-    const graphsToUpdate = await db.query.agentGraph.findMany({
-      where: and(eq(agentGraph.tenantId, tenantId), eq(agentGraph.projectId, projectId))
+    const agentsToUpdate = await db.query.agents.findMany({
+      where: and(eq(agents.tenantId, tenantId), eq(agents.projectId, projectId))
     });
-    for (const graph of graphsToUpdate) {
-      const graphStopWhen = graph.stopWhen;
-      if (!graphStopWhen?.transferCountIs || graphStopWhen.transferCountIs === oldStopWhen?.transferCountIs) {
+    for (const agent of agentsToUpdate) {
+      const agentStopWhen = agent.stopWhen;
+      if (!agentStopWhen?.transferCountIs || agentStopWhen.transferCountIs === oldStopWhen?.transferCountIs) {
         const updatedStopWhen = {
-          ...graphStopWhen || {},
+          ...agentStopWhen || {},
           transferCountIs: newStopWhen?.transferCountIs
         };
-        await db.update(agentGraph).set({
+        await db.update(agents).set({
           stopWhen: updatedStopWhen,
           updatedAt: (/* @__PURE__ */ new Date()).toISOString()
         }).where(
           and(
-            eq(agentGraph.tenantId, tenantId),
-            eq(agentGraph.projectId, projectId),
-            eq(agentGraph.id, graph.id)
+            eq(agents.tenantId, tenantId),
+            eq(agents.projectId, projectId),
+            eq(agents.id, agent.id)
           )
         );
       }
@@ -219385,7 +219372,7 @@ var createFullProjectServerSide = (db, logger13 = defaultLogger2) => async (scop
     {
       tenantId,
       projectId: typed.id,
-      graphCount: Object.keys(typed.graphs || {}).length
+      agentCount: Object.keys(typed.agents || {}).length
     },
     "Creating full project in database"
   );
@@ -219604,19 +219591,19 @@ var createFullProjectServerSide = (db, logger13 = defaultLogger2) => async (scop
         "All project artifactComponents created successfully"
       );
     }
-    if (typed.graphs && Object.keys(typed.graphs).length > 0) {
+    if (typed.agents && Object.keys(typed.agents).length > 0) {
       logger13.info(
         {
           projectId: typed.id,
-          graphCount: Object.keys(typed.graphs).length
+          agentCount: Object.keys(typed.agents).length
         },
-        "Creating project graphs"
+        "Creating project agent"
       );
-      const graphPromises = Object.entries(typed.graphs).map(async ([graphId, graphData]) => {
+      const agentPromises = Object.entries(typed.agents).map(async ([agentId, agentData]) => {
         try {
-          logger13.info({ projectId: typed.id, graphId }, "Creating graph in project");
-          const graphDataWithProjectResources = {
-            ...graphData,
+          logger13.info({ projectId: typed.id, agentId }, "Creating agent in project");
+          const agentDataWithProjectResources = {
+            ...agentData,
             tools: typed.tools || {},
             // Pass project-level MCP tools for validation
             functions: typed.functions || {},
@@ -219624,28 +219611,28 @@ var createFullProjectServerSide = (db, logger13 = defaultLogger2) => async (scop
             dataComponents: typed.dataComponents || {},
             artifactComponents: typed.artifactComponents || {},
             credentialReferences: typed.credentialReferences || {},
-            statusUpdates: graphData.statusUpdates === null ? void 0 : graphData.statusUpdates
+            statusUpdates: agentData.statusUpdates === null ? void 0 : agentData.statusUpdates
           };
-          await createFullGraphServerSide(db, logger13)(
+          await createFullAgentServerSide(db, logger13)(
             { tenantId, projectId: typed.id },
-            graphDataWithProjectResources
+            agentDataWithProjectResources
           );
-          logger13.info({ projectId: typed.id, graphId }, "Graph created successfully in project");
+          logger13.info({ projectId: typed.id, agentId }, "Agent created successfully in project");
         } catch (error) {
           logger13.error(
-            { projectId: typed.id, graphId, error },
-            "Failed to create graph in project"
+            { projectId: typed.id, agentId, error },
+            "Failed to create agent in project"
           );
           throw error;
         }
       });
-      await Promise.all(graphPromises);
+      await Promise.all(agentPromises);
       logger13.info(
         {
           projectId: typed.id,
-          graphCount: Object.keys(typed.graphs).length
+          agentCount: Object.keys(typed.agents).length
         },
-        "All project graphs created successfully"
+        "All project agent created successfully"
       );
     }
     logger13.info({ projectId: typed.id }, "Full project created successfully");
@@ -219677,7 +219664,7 @@ var updateFullProjectServerSide = (db, logger13 = defaultLogger2) => async (scop
     {
       tenantId,
       projectId: typed.id,
-      graphCount: Object.keys(typed.graphs || {}).length
+      agentCount: Object.keys(typed.agents || {}).length
     },
     "Updating full project in database"
   );
@@ -219912,52 +219899,52 @@ var updateFullProjectServerSide = (db, logger13 = defaultLogger2) => async (scop
         "All project artifactComponents updated successfully"
       );
     }
-    const incomingGraphIds = new Set(Object.keys(typed.graphs || {}));
-    const existingGraphs = await listAgentGraphs(db)({
+    const incomingAgentIds = new Set(Object.keys(typed.agents || {}));
+    const existingAgents = await listAgents(db)({
       scopes: { tenantId, projectId: typed.id }
     });
-    let deletedGraphCount = 0;
-    for (const graph of existingGraphs) {
-      if (!incomingGraphIds.has(graph.id)) {
+    let deletedAgentCount = 0;
+    for (const agent of existingAgents) {
+      if (!incomingAgentIds.has(agent.id)) {
         try {
-          await deleteFullGraph(
+          await deleteFullAgent(
             db,
             logger13
           )({
-            scopes: { tenantId, projectId: typed.id, graphId: graph.id }
+            scopes: { tenantId, projectId: typed.id, agentId: agent.id }
           });
-          deletedGraphCount++;
-          logger13.info({ graphId: graph.id }, "Deleted orphaned graph from project");
+          deletedAgentCount++;
+          logger13.info({ agentId: agent.id }, "Deleted orphaned agent from project");
         } catch (error) {
           logger13.error(
-            { graphId: graph.id, error },
-            "Failed to delete orphaned graph from project"
+            { agentId: agent.id, error },
+            "Failed to delete orphaned agent from project"
           );
         }
       }
     }
-    if (deletedGraphCount > 0) {
+    if (deletedAgentCount > 0) {
       logger13.info(
         {
-          deletedGraphCount,
+          deletedAgentCount,
           projectId: typed.id
         },
-        "Deleted orphaned graphs from project"
+        "Deleted orphaned agent from project"
       );
     }
-    if (typed.graphs && Object.keys(typed.graphs).length > 0) {
+    if (typed.agents && Object.keys(typed.agents).length > 0) {
       logger13.info(
         {
           projectId: typed.id,
-          graphCount: Object.keys(typed.graphs).length
+          agentCount: Object.keys(typed.agents).length
         },
-        "Updating project graphs"
+        "Updating project agent"
       );
-      const graphPromises = Object.entries(typed.graphs).map(async ([graphId, graphData]) => {
+      const agentPromises = Object.entries(typed.agents).map(async ([agentId, agentData]) => {
         try {
-          logger13.info({ projectId: typed.id, graphId }, "Updating graph in project");
-          const graphDataWithProjectResources = {
-            ...graphData,
+          logger13.info({ projectId: typed.id, agentId }, "Updating agent in project");
+          const agentDataWithProjectResources = {
+            ...agentData,
             tools: typed.tools || {},
             // Pass project-level MCP tools for validation
             functions: typed.functions || {},
@@ -219965,28 +219952,28 @@ var updateFullProjectServerSide = (db, logger13 = defaultLogger2) => async (scop
             dataComponents: typed.dataComponents || {},
             artifactComponents: typed.artifactComponents || {},
             credentialReferences: typed.credentialReferences || {},
-            statusUpdates: graphData.statusUpdates === null ? void 0 : graphData.statusUpdates
+            statusUpdates: agentData.statusUpdates === null ? void 0 : agentData.statusUpdates
           };
-          await updateFullGraphServerSide(db, logger13)(
+          await updateFullAgentServerSide(db, logger13)(
             { tenantId, projectId: typed.id },
-            graphDataWithProjectResources
+            agentDataWithProjectResources
           );
-          logger13.info({ projectId: typed.id, graphId }, "Graph updated successfully in project");
+          logger13.info({ projectId: typed.id, agentId }, "Agent updated successfully in project");
         } catch (error) {
           logger13.error(
-            { projectId: typed.id, graphId, error },
-            "Failed to update graph in project"
+            { projectId: typed.id, agentId, error },
+            "Failed to update agent in project"
           );
           throw error;
         }
       });
-      await Promise.all(graphPromises);
+      await Promise.all(agentPromises);
       logger13.info(
         {
           projectId: typed.id,
-          graphCount: Object.keys(typed.graphs).length
+          agentCount: Object.keys(typed.agents).length
         },
-        "All project graphs updated successfully"
+        "All project agent updated successfully"
       );
     }
     logger13.info({ projectId: typed.id }, "Full project updated successfully");
@@ -220021,16 +220008,16 @@ var getFullProject = (db, logger13 = defaultLogger2) => async (params) => {
       return null;
     }
     logger13.info({ tenantId, projectId }, "Project metadata retrieved");
-    const graphList = await listAgentGraphs(db)({
+    const agentList = await listAgents(db)({
       scopes: { tenantId, projectId }
     });
     logger13.info(
       {
         tenantId,
         projectId,
-        graphCount: graphList.length
+        agentCount: agentList.length
       },
-      "Found graphs for project"
+      "Found agent for project"
     );
     const projectTools = {};
     try {
@@ -220128,34 +220115,34 @@ var getFullProject = (db, logger13 = defaultLogger2) => async (params) => {
         "Failed to retrieve credentialReferences for project"
       );
     }
-    const graphs = {};
-    if (graphList.length > 0) {
-      const graphPromises = graphList.map(async (graph) => {
+    const agents2 = {};
+    if (agentList.length > 0) {
+      const agentPromises = agentList.map(async (agent) => {
         try {
           logger13.info(
-            { tenantId, projectId, graphId: graph.id },
-            "Retrieving full graph definition"
+            { tenantId, projectId, agentId: agent.id },
+            "Retrieving full agent definition"
           );
-          const fullGraph = await getFullGraph(db)({
-            scopes: { tenantId, projectId, graphId: graph.id }
+          const fullAgent = await getFullAgent(db)({
+            scopes: { tenantId, projectId, agentId: agent.id }
           });
-          if (fullGraph) {
-            graphs[graph.id] = fullGraph;
+          if (fullAgent) {
+            agents2[agent.id] = fullAgent;
             logger13.info(
-              { tenantId, projectId, graphId: graph.id },
-              "Full graph definition retrieved"
+              { tenantId, projectId, agentId: agent.id },
+              "Full agent definition retrieved"
             );
           } else {
-            logger13.warn({ tenantId, projectId, graphId: graph.id }, "Graph definition not found");
+            logger13.warn({ tenantId, projectId, agentId: agent.id }, "Agent definition not found");
           }
         } catch (error) {
           logger13.error(
-            { tenantId, projectId, graphId: graph.id, error },
-            "Failed to retrieve full graph definition"
+            { tenantId, projectId, agentId: agent.id, error },
+            "Failed to retrieve full agent definition"
           );
         }
       });
-      await Promise.all(graphPromises);
+      await Promise.all(agentPromises);
     }
     if (!project.models) {
       throw new Error(
@@ -220168,7 +220155,7 @@ var getFullProject = (db, logger13 = defaultLogger2) => async (params) => {
       description: project.description,
       models: project.models,
       stopWhen: project.stopWhen || void 0,
-      graphs,
+      agents: agents2,
       tools: projectTools,
       dataComponents: projectDataComponents,
       artifactComponents: projectArtifactComponents,
@@ -220180,7 +220167,7 @@ var getFullProject = (db, logger13 = defaultLogger2) => async (params) => {
       {
         tenantId,
         projectId,
-        graphCount: Object.keys(fullProjectDefinition.graphs).length
+        agentCount: Object.keys(fullProjectDefinition.agents).length
       },
       "Full project definition retrieved"
     );
@@ -220212,44 +220199,44 @@ var deleteFullProject = (db, logger13 = defaultLogger2) => async (params) => {
       logger13.info({ tenantId, projectId }, "Project not found for deletion");
       return false;
     }
-    if (project.graphs && Object.keys(project.graphs).length > 0) {
+    if (project.agents && Object.keys(project.agents).length > 0) {
       logger13.info(
         {
           tenantId,
           projectId,
-          graphCount: Object.keys(project.graphs).length
+          agentCount: Object.keys(project.agents).length
         },
-        "Deleting project graphs"
+        "Deleting project agent"
       );
-      const graphPromises = Object.keys(project.graphs).map(async (graphId) => {
+      const agentPromises = Object.keys(project.agents).map(async (agentId) => {
         try {
-          logger13.info({ tenantId, projectId, graphId }, "Deleting graph from project");
-          await deleteFullGraph(
+          logger13.info({ tenantId, projectId, agentId }, "Deleting agent from project");
+          await deleteFullAgent(
             db,
             logger13
           )({
-            scopes: { tenantId, projectId, graphId }
+            scopes: { tenantId, projectId, agentId }
           });
           logger13.info(
-            { tenantId, projectId, graphId },
-            "Graph deleted successfully from project"
+            { tenantId, projectId, agentId },
+            "Agent deleted successfully from project"
           );
         } catch (error) {
           logger13.error(
-            { tenantId, projectId, graphId, error },
-            "Failed to delete graph from project"
+            { tenantId, projectId, agentId, error },
+            "Failed to delete agent from project"
           );
           throw error;
         }
       });
-      await Promise.all(graphPromises);
+      await Promise.all(agentPromises);
       logger13.info(
         {
           tenantId,
           projectId,
-          graphCount: Object.keys(project.graphs).length
+          agentCount: Object.keys(project.agents).length
         },
-        "All project graphs deleted successfully"
+        "All project agent deleted successfully"
       );
     }
     const deleted = await deleteProject(db)({
@@ -221038,10 +221025,7 @@ async function fetchExistingHeaders({
   credentialStores
 }) {
   const contextResolver = new ContextResolver(tenantId, projectId, dbClient, credentialStores);
-  const headers2 = await contextResolver.resolveHeaders(
-    conversationId,
-    contextConfig2.id
-  );
+  const headers2 = await contextResolver.resolveHeaders(conversationId, contextConfig2.id);
   if (Object.keys(headers2).length > 0) {
     return {
       valid: true,
@@ -221049,25 +221033,23 @@ async function fetchExistingHeaders({
       validatedContext: headers2
     };
   }
-  throw new Error(
-    "No headers found in cache. Please provide headers in request."
-  );
+  throw new Error("No headers found in cache. Please provide headers in request.");
 }
 async function validateHeaders({
   tenantId,
   projectId,
-  graphId,
+  agentId,
   conversationId,
   parsedRequest,
   dbClient,
   credentialStores
 }) {
   try {
-    const agentGraph2 = await getAgentGraphWithDefaultSubAgent(dbClient)({
-      scopes: { tenantId, projectId, graphId }
+    const agent = await getAgentWithDefaultSubAgent(dbClient)({
+      scopes: { tenantId, projectId, agentId }
     });
-    if (!agentGraph2?.contextConfigId) {
-      logger9.debug({ graphId }, "No context config found for graph, skipping validation");
+    if (!agent?.contextConfigId) {
+      logger9.debug({ agentId }, "No context config found for agent, skipping validation");
       return {
         valid: true,
         errors: [],
@@ -221075,11 +221057,11 @@ async function validateHeaders({
       };
     }
     const contextConfig2 = await getContextConfigById(dbClient)({
-      scopes: { tenantId, projectId, graphId },
-      id: agentGraph2.contextConfigId
+      scopes: { tenantId, projectId, agentId },
+      id: agent.contextConfigId
     });
     if (!contextConfig2) {
-      logger9.warn({ contextConfigId: agentGraph2.contextConfigId }, "Context config not found");
+      logger9.warn({ contextConfigId: agent.contextConfigId }, "Context config not found");
       return {
         valid: false,
         errors: [
@@ -221147,7 +221129,7 @@ async function validateHeaders({
     logger9.error(
       {
         tenantId,
-        graphId,
+        agentId,
         error: error instanceof Error ? error.message : "Unknown error"
       },
       "Failed to validate headers"
@@ -221167,13 +221149,13 @@ function contextValidationMiddleware(dbClient) {
   return async (c, next) => {
     try {
       const executionContext = getRequestExecutionContext(c);
-      let { tenantId, projectId, graphId } = executionContext;
-      if (!tenantId || !projectId || !graphId) {
+      let { tenantId, projectId, agentId } = executionContext;
+      if (!tenantId || !projectId || !agentId) {
         tenantId = c.req.param("tenantId");
         projectId = c.req.param("projectId");
-        graphId = c.req.param("graphId");
+        agentId = c.req.param("agentId");
       }
-      if (!tenantId || !projectId || !graphId) {
+      if (!tenantId || !projectId || !agentId) {
         return next();
       }
       const body = c.get("requestBody") || {};
@@ -221189,7 +221171,7 @@ function contextValidationMiddleware(dbClient) {
       const validationResult = await validateHeaders({
         tenantId,
         projectId,
-        graphId,
+        agentId,
         conversationId,
         parsedRequest,
         dbClient,
@@ -221199,7 +221181,7 @@ function contextValidationMiddleware(dbClient) {
         logger9.warn(
           {
             tenantId,
-            graphId,
+            agentId,
             errors: validationResult.errors
           },
           "Headers validation failed"
@@ -221214,7 +221196,7 @@ function contextValidationMiddleware(dbClient) {
       logger9.debug(
         {
           tenantId,
-          graphId,
+          agentId,
           contextKeys: Object.keys(validationResult.validatedContext || {})
         },
         "Request context validation successful"
@@ -221241,8 +221223,8 @@ var checkGraphQLErrors = (data) => {
   if (data && typeof data === "object" && "errors" in data) {
     const errorObj = data;
     if (Array.isArray(errorObj.errors) && errorObj.errors.length > 0) {
-      const graphqlErrors = errorObj.errors;
-      const errorMessage = `GraphQL request failed with ${graphqlErrors.length} errors: ${graphqlErrors.map((e) => e.message || "Unknown error").join(", ")}`;
+      const agentqlErrors = errorObj.errors;
+      const errorMessage = `GraphQL request failed with ${agentqlErrors.length} errors: ${agentqlErrors.map((e) => e.message || "Unknown error").join(", ")}`;
       throw new Error(errorMessage);
     }
   }
@@ -221587,7 +221569,7 @@ async function determineContextTrigger(tenantId, projectId, conversationId, dbCl
   }
   return "invocation";
 }
-async function handleContextConfigChange(tenantId, projectId, conversationId, graphId, newContextConfigId, dbClient, credentialStores) {
+async function handleContextConfigChange(tenantId, projectId, conversationId, agentId, newContextConfigId, dbClient, credentialStores) {
   const conversation = await getConversation(dbClient)({
     scopes: { tenantId, projectId },
     conversationId
@@ -221599,7 +221581,7 @@ async function handleContextConfigChange(tenantId, projectId, conversationId, gr
     logger11.info(
       {
         conversationId,
-        graphId,
+        agentId,
         contextConfigId: newContextConfigId
       },
       "Potential context config change for existing conversation, cache cleared"
@@ -221609,7 +221591,7 @@ async function handleContextConfigChange(tenantId, projectId, conversationId, gr
 async function handleContextResolution({
   tenantId,
   projectId,
-  graphId,
+  agentId,
   conversationId,
   headers: headers2,
   dbClient,
@@ -221623,38 +221605,38 @@ async function handleContextResolution({
       }
     },
     async (parentSpan) => {
-      let agentGraph2;
+      let agent;
       let trigger;
       try {
-        agentGraph2 = await getAgentGraphWithDefaultSubAgent(dbClient)({
-          scopes: { tenantId, projectId, graphId }
+        agent = await getAgentWithDefaultSubAgent(dbClient)({
+          scopes: { tenantId, projectId, agentId }
         });
-        if (!agentGraph2?.contextConfigId) {
-          logger11.debug({ graphId }, "No context config found for graph");
+        if (!agent?.contextConfigId) {
+          logger11.debug({ agentId }, "No context config found for agent");
           return null;
         }
         await handleContextConfigChange(
           tenantId,
           projectId,
           conversationId,
-          graphId,
-          agentGraph2.contextConfigId,
+          agentId,
+          agent.contextConfigId,
           dbClient,
           credentialStores
         );
         trigger = await determineContextTrigger(tenantId, projectId, conversationId, dbClient);
         const contextConfig2 = await getContextConfigById(dbClient)({
-          scopes: { tenantId, projectId, graphId },
-          id: agentGraph2.contextConfigId
+          scopes: { tenantId, projectId, agentId },
+          id: agent.contextConfigId
         });
         if (!contextConfig2) {
           logger11.warn(
-            { contextConfigId: agentGraph2.contextConfigId },
+            { contextConfigId: agent.contextConfigId },
             "Context config not found, proceeding without context resolution"
           );
           parentSpan.setStatus({ code: SpanStatusCode.ERROR });
           parentSpan.addEvent("context.config_not_found", {
-            contextConfigId: agentGraph2.contextConfigId
+            contextConfigId: agent.contextConfigId
           });
           return null;
         }
@@ -221693,7 +221675,7 @@ async function handleContextResolution({
         logger11.info(
           {
             conversationId,
-            graphId,
+            agentId,
             contextConfigId: contextConfig2.id,
             trigger,
             resolvedKeys: Object.keys(resolvedContext),
@@ -221702,7 +221684,7 @@ async function handleContextResolution({
             fetchedDefinitions: contextResult.fetchedDefinitions.length,
             errors: contextResult.errors.length
           },
-          "Context resolution completed (contextConfigId derived from graph)"
+          "Context resolution completed (contextConfigId derived from agent)"
         );
         return resolvedContext;
       } catch (error) {
@@ -221715,7 +221697,7 @@ async function handleContextResolution({
         logger11.error(
           {
             error: errorMessage,
-            contextConfigId: agentGraph2?.contextConfigId,
+            contextConfigId: agent?.contextConfigId,
             trigger: await determineContextTrigger(
               tenantId,
               projectId,
@@ -222573,4 +222555,4 @@ typescript/lib/typescript.js:
   ***************************************************************************** *)
 */
 
-export { ContextCache, ContextConfigBuilder, ContextFetcher, ContextResolver, CredentialStoreRegistry, CredentialStuffer, ERROR_DOCS_BASE_URL, ErrorCode, HTTP_REQUEST_PARTS, InMemoryCredentialStore, KeyChainStore, McpClient, NangoCredentialStore, TemplateEngine, addFunctionToolToSubAgent, 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, createFunctionTool, 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, deleteFunctionTool, 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, getFunctionToolById, getFunctionToolsForSubAgent, 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, listFunctionTools, 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, updateFunctionTool, updateMessage, updateProject, updateSubAgent, updateSubAgentFunctionToolRelation, updateTask, updateTool, upsertAgentArtifactComponentRelation, upsertAgentDataComponentRelation, upsertAgentGraph, upsertAgentRelation, upsertArtifactComponent, upsertContextConfig, upsertCredentialReference, upsertDataComponent, upsertExternalAgent, upsertFunction, upsertFunctionTool, upsertLedgerArtifact, upsertSubAgent, upsertSubAgentFunctionToolRelation, upsertSubAgentToolRelation, upsertTool, validateAgainstJsonSchema, validateAndGetApiKey, validateApiKey, validateExternalAgent, validateHeaders, validateHttpRequestHeaders, validateInternalSubAgent, validateProjectExists, validationHelper, withProjectValidation };
+export { ContextCache, ContextConfigBuilder, ContextFetcher, ContextResolver, CredentialStoreRegistry, CredentialStuffer, ERROR_DOCS_BASE_URL, ErrorCode, HTTP_REQUEST_PARTS, InMemoryCredentialStore, KeyChainStore, McpClient, NangoCredentialStore, TemplateEngine, addFunctionToolToSubAgent, addLedgerArtifacts, addToolToAgent, agentHasArtifactComponents, apiFetch, associateArtifactComponentWithAgent, associateDataComponentWithAgent, cleanupTenantCache, clearContextConfigCache, clearConversationCache, commonCreateErrorResponses, commonDeleteErrorResponses, commonGetErrorResponses, commonUpdateErrorResponses, contextConfig, contextValidationMiddleware, countApiKeys, countArtifactComponents, countArtifactComponentsForAgent, countContextConfigs, countCredentialReferences, countDataComponents, countExternalAgents, countLedgerArtifactsByTask, countMessagesByConversation, countProjects, createAgent, createAgentToolRelation, createApiError, createApiKey, createArtifactComponent, createContextConfig, createConversation, createCredentialReference, createDataComponent, createDatabaseClient, createDefaultCredentialStores, createExecutionContext, createExternalAgent, createExternalAgentRelation, createFullAgentServerSide, createFullProjectServerSide, createFunctionTool, createInMemoryDatabaseClient, createKeyChainStore, createMessage, createNangoCredentialStore, createOrGetConversation, createProject, createSubAgent, createSubAgentRelation, createTask, createTool, createValidatedDataAccess, dbResultToMcpTool, deleteAgent, deleteAgentArtifactComponentRelationByAgent, deleteAgentDataComponentRelationByAgent, deleteAgentRelationsByAgent, deleteAgentToolRelation, deleteAgentToolRelationByAgent, deleteApiKey, deleteArtifactComponent, deleteContextConfig, deleteConversation, deleteCredentialReference, deleteDataComponent, deleteExternalAgent, deleteFullAgent, deleteFullProject, deleteFunction, deleteFunctionTool, deleteLedgerArtifactsByContext, deleteLedgerArtifactsByTask, deleteMessage, deleteProject, deleteSubAgent, deleteSubAgentRelation, deleteTool, detectAuthenticationRequired, determineContextTrigger, discoverOAuthEndpoints, errorResponseSchema, errorSchemaFactory, externalAgentExists, externalAgentUrlExists, extractPublicId, fetchComponentRelationships, fetchDefinition, generateAndCreateApiKey, generateApiKey, generateId, getActiveAgentForConversation, getAgentById, getAgentRelationById, getAgentRelationByParams, getAgentRelations, getAgentRelationsByAgent, getAgentRelationsBySource, getAgentRelationsByTarget, getAgentSubAgentInfos, getAgentToolRelationByAgent, getAgentToolRelationById, getAgentToolRelationByTool, getAgentWithDefaultSubAgent, getAgentsForTool, getAgentsUsingArtifactComponent, getAgentsUsingDataComponent, getApiKeyById, getApiKeyByPublicId, getArtifactComponentById, getArtifactComponentsForAgent, getCacheEntry, getCachedValidator, getContextConfigById, getContextConfigCacheEntries, getConversation, getConversationCacheEntries, getConversationHistory, getConversationId, getCredentialReference, getCredentialReferenceById, getCredentialReferenceWithTools, getCredentialStoreLookupKeyFromRetrievalParams, getDataComponent, getDataComponentsForAgent, getExternalAgent, getExternalAgentByUrl, getExternalAgentRelations, getFullAgent, getFullAgentDefinition, getFullProject, getFunction, getFunctionToolById, getFunctionToolsForSubAgent, getLedgerArtifacts, getLedgerArtifactsByContext, getMessageById, getMessagesByConversation, getMessagesByTask, getProject, getProjectResourceCounts, getRelatedAgentsForAgent, getRequestExecutionContext, getSubAgentById, getSubAgentsByIds, getTask, getToolById, getToolsForAgent, getTracer, getVisibleMessages, handleApiError, handleContextConfigChange, handleContextResolution, hasApiKey, hasContextConfig, hasCredentialReference, hashApiKey, headers, invalidateHeadersCache, invalidateInvocationDefinitionsCache, isApiKeyExpired, isArtifactComponentAssociatedWithAgent, isDataComponentAssociatedWithAgent, isValidHttpRequest, listAgentRelations, listAgentToolRelations, listAgents, listAgentsPaginated, listApiKeys, listApiKeysPaginated, listArtifactComponents, listArtifactComponentsPaginated, listContextConfigs, listContextConfigsPaginated, listConversations, listCredentialReferences, listCredentialReferencesPaginated, listDataComponents, listDataComponentsPaginated, listExternalAgents, listExternalAgentsPaginated, listFunctionTools, listFunctions, listMessages, listProjects, listProjectsPaginated, listSubAgents, listSubAgentsPaginated, listTaskIdsByContextId, listTools, loadEnvironmentFiles, maskApiKey, problemDetailsSchema, projectExists, projectExistsInTable, projectHasResources, removeArtifactComponentFromAgent, removeDataComponentFromAgent, removeToolFromAgent, setActiveAgentForConversation, setActiveAgentForThread, setCacheEntry, setSpanWithError, updateAgent, updateAgentRelation, updateAgentToolRelation, updateApiKey, updateApiKeyLastUsed, updateArtifactComponent, updateContextConfig, updateConversation, updateConversationActiveAgent, updateCredentialReference, updateDataComponent, updateExternalAgent, updateFullAgentServerSide, updateFullProjectServerSide, updateFunctionTool, updateMessage, updateProject, updateSubAgent, updateSubAgentFunctionToolRelation, updateTask, updateTool, upsertAgent, upsertAgentArtifactComponentRelation, upsertAgentDataComponentRelation, upsertAgentRelation, upsertArtifactComponent, upsertContextConfig, upsertCredentialReference, upsertDataComponent, upsertExternalAgent, upsertFunction, upsertFunctionTool, upsertLedgerArtifact, upsertSubAgent, upsertSubAgentFunctionToolRelation, upsertSubAgentToolRelation, upsertTool, validateAgainstJsonSchema, validateAndGetApiKey, validateApiKey, validateExternalAgent, validateHeaders, validateHttpRequestHeaders, validateInternalSubAgent, validateProjectExists, validationHelper, withProjectValidation };