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

package/dist/index.cjs

@@ -212935,7 +212935,7 @@ var SPAN_NAMES = {
   CONTEXT_HANDLE: "context.handle_context_resolution",
   AGENT_GENERATION: "agent.generate",
   CONTEXT_FETCHER: "context-fetcher.http-request",
-  ARTIFACT_PROCESSING: "graph_session.process_artifact"
+  ARTIFACT_PROCESSING: "agent_session.process_artifact"
 };
 var AI_OPERATIONS = {
   GENERATE_TEXT: "ai.generateText.doGenerate",
@@ -212951,14 +212951,14 @@ var SPAN_KEYS = {
   STATUS_MESSAGE: "status_message",
   OTEL_STATUS_CODE: "otel.status_code",
   OTEL_STATUS_DESCRIPTION: "otel.status_description",
-  // Graph attributes
-  GRAPH_ID: "graph.id",
-  GRAPH_NAME: "graph.name",
+  // Agent attributesa
+  AGENT_ID: "agent.id",
+  AGENT_NAME: "agent.name",
   TENANT_ID: "tenant.id",
   PROJECT_ID: "project.id",
   // AI/Agent attributes
-  AI_AGENT_NAME: "ai.agentName",
-  AI_AGENT_NAME_ALT: "ai.agent.name",
+  AI_SUB_AGENT_NAME: "ai.subAgentName",
+  AI_SUB_AGENT_NAME_ALT: "ai.subAgent.name",
   AI_OPERATION_ID: "ai.operationId",
   AI_RESPONSE_TIMESTAMP: "ai.response.timestamp",
   AI_RESPONSE_CONTENT: "ai.response.content",
@@ -212976,16 +212976,16 @@ var SPAN_KEYS = {
   AI_TOOL_CALL_ID: "ai.toolCall.id",
   AI_TOOL_TYPE: "ai.toolType",
   TOOL_PURPOSE: "tool.purpose",
-  // Agent attributes
-  AGENT_ID: "agent.id",
-  AGENT_NAME: "agent.name",
+  // SubAgent attributes
+  SUB_AGENT_ID: "subagent.id",
+  SUB_AGENT_NAME: "subagent.name",
   // Token usage
   GEN_AI_USAGE_INPUT_TOKENS: "gen_ai.usage.input_tokens",
   GEN_AI_USAGE_OUTPUT_TOKENS: "gen_ai.usage.output_tokens",
   // Context attributes
   CONTEXT_URL: "context.url",
   CONTEXT_CONFIG_ID: "context.context_config_id",
-  CONTEXT_AGENT_GRAPH_ID: "context.agent_graph_id",
+  CONTEXT_AGENT_ID: "context.agent_id",
   CONTEXT_HEADERS_KEYS: "context.headers_keys",
   // Message attributes
   MESSAGE_CONTENT: "message.content",
@@ -213137,7 +213137,7 @@ var QUERY_EXPRESSIONS = {
   CONTEXT_ERRORS: "contextErrors",
   AGENT_GENERATION_ERRORS: "agentGenerationErrors",
   USER_MESSAGES: "userMessages",
-  UNIQUE_GRAPHS: "uniqueGraphs",
+  UNIQUE_AGENTS: "uniqueAgents",
   UNIQUE_MODELS: "uniqueModels",
   // Route-specific query names
   TOOL_CALLS: "toolCalls",
@@ -213171,7 +213171,7 @@ var QUERY_TYPES = {
 var PANEL_TYPES = {
   LIST: "list",
   TABLE: "table",
-  GRAPH: "graph",
+  AGENT: "agent",
   VALUE: "value"
 };
 var DATA_SOURCES = {
@@ -213423,9 +213423,9 @@ var schema_exports = {};
 __export(schema_exports, {
   agentFunctionToolRelations: () => agentFunctionToolRelations,
   agentFunctionToolRelationsRelations: () => agentFunctionToolRelationsRelations,
-  agentGraph: () => agentGraph,
-  agentGraphRelations: () => agentGraphRelations,
+  agentRelations: () => agentRelations,
   agentToolRelationsRelations: () => agentToolRelationsRelations,
+  agents: () => agents,
   apiKeys: () => apiKeys,
   apiKeysRelations: () => apiKeysRelations,
   artifactComponents: () => artifactComponents,
@@ -213476,12 +213476,12 @@ var projectScoped = {
   ...tenantScoped,
   projectId: sqliteCore.text("project_id").notNull()
 };
-var graphScoped = {
+var agentScoped = {
   ...projectScoped,
-  graphId: sqliteCore.text("graph_id").notNull()
+  agentId: sqliteCore.text("agent_id").notNull()
 };
 var subAgentScoped = {
-  ...graphScoped,
+  ...agentScoped,
   subAgentId: sqliteCore.text("sub_agent_id").notNull()
 };
 var uiProperties = {
@@ -213497,9 +213497,9 @@ var projects = sqliteCore.sqliteTable(
   {
     ...tenantScoped,
     ...uiProperties,
-    // Project-level default model settings that can be inherited by graphs and agents
+    // Project-level default model settings that can be inherited by agents
     models: sqliteCore.text("models", { mode: "json" }).$type(),
-    // Project-level stopWhen configuration that can be inherited by graphs and agents
+    // Project-level stopWhen configuration that can be inherited by agents
     stopWhen: sqliteCore.text("stop_when", { mode: "json" }).$type(),
     // Project-level sandbox configuration for function execution
     sandboxConfig: sqliteCore.text("sandbox_config", { mode: "json" }).$type(),
@@ -213507,23 +213507,17 @@ var projects = sqliteCore.sqliteTable(
   },
   (table) => [sqliteCore.primaryKey({ columns: [table.tenantId, table.id] })]
 );
-var agentGraph = sqliteCore.sqliteTable(
-  "agent_graph",
+var agents = sqliteCore.sqliteTable(
+  "agent",
   {
     ...projectScoped,
     name: sqliteCore.text("name").notNull(),
     description: sqliteCore.text("description"),
     defaultSubAgentId: sqliteCore.text("default_sub_agent_id"),
-    // Reference to shared context configuration for all agents in this graph
     contextConfigId: sqliteCore.text("context_config_id"),
-    // add fk relationship
-    // Graph-level model settingsuration that can be inherited by agents
     models: sqliteCore.text("models", { mode: "json" }).$type(),
-    // Status updates configuration for intelligent progress summaries
     statusUpdates: sqliteCore.text("status_updates", { mode: "json" }).$type(),
-    // Graph-level prompt that can be used as additional context for agents
-    graphPrompt: sqliteCore.text("graph_prompt"),
-    // Graph-level stopWhen configuration that can be inherited by agents
+    prompt: sqliteCore.text("prompt"),
     stopWhen: sqliteCore.text("stop_when", { mode: "json" }).$type(),
     ...timestamps
   },
@@ -213532,27 +213526,26 @@ var agentGraph = sqliteCore.sqliteTable(
     sqliteCore.foreignKey({
       columns: [table.tenantId, table.projectId],
       foreignColumns: [projects.tenantId, projects.id],
-      name: "agent_graph_project_fk"
+      name: "agent_project_fk"
     }).onDelete("cascade")
   ]
 );
 var contextConfigs = sqliteCore.sqliteTable(
   "context_configs",
   {
-    ...graphScoped,
+    ...agentScoped,
     // Developer-defined Zod schema for validating incoming request context
     headersSchema: sqliteCore.blob("headers_schema", { mode: "json" }).$type(),
-    // Stores serialized Zod schema
     // Object mapping template keys to fetch definitions that use request context data
     contextVariables: sqliteCore.blob("context_variables", { mode: "json" }).$type(),
     ...timestamps
   },
   (table) => [
-    sqliteCore.primaryKey({ columns: [table.tenantId, table.projectId, table.graphId, table.id] }),
+    sqliteCore.primaryKey({ columns: [table.tenantId, table.projectId, table.agentId, table.id] }),
     sqliteCore.foreignKey({
-      columns: [table.tenantId, table.projectId, table.graphId],
-      foreignColumns: [agentGraph.tenantId, agentGraph.projectId, agentGraph.id],
-      name: "context_configs_graph_fk"
+      columns: [table.tenantId, table.projectId, table.agentId],
+      foreignColumns: [agents.tenantId, agents.projectId, agents.id],
+      name: "context_configs_agent_fk"
     }).onDelete("cascade")
   ]
 );
@@ -213565,16 +213558,12 @@ var contextCache = sqliteCore.sqliteTable(
     // Reference to the context config and specific fetch definition
     contextConfigId: sqliteCore.text("context_config_id").notNull(),
     contextVariableKey: sqliteCore.text("context_variable_key").notNull(),
-    // Key from contextVariables object
-    // The actual cached context data
     value: sqliteCore.blob("value", { mode: "json" }).$type().notNull(),
     // Request hash for cache invalidation based on context changes
     requestHash: sqliteCore.text("request_hash"),
-    // Hash of request context that triggered this cache
     // Metadata for monitoring and debugging
     fetchedAt: sqliteCore.text("fetched_at").notNull(),
     fetchSource: sqliteCore.text("fetch_source"),
-    // URL or source identifier
     fetchDurationMs: sqliteCore.integer("fetch_duration_ms"),
     ...timestamps
   },
@@ -213595,30 +213584,29 @@ var contextCache = sqliteCore.sqliteTable(
 var subAgents = sqliteCore.sqliteTable(
   "sub_agents",
   {
-    ...graphScoped,
+    ...agentScoped,
     ...uiProperties,
     prompt: sqliteCore.text("prompt").notNull(),
     conversationHistoryConfig: sqliteCore.text("conversation_history_config", {
       mode: "json"
     }).$type(),
     models: sqliteCore.text("models", { mode: "json" }).$type(),
-    // Agent-level stopWhen configuration (inherited from project)
     stopWhen: sqliteCore.text("stop_when", { mode: "json" }).$type(),
     ...timestamps
   },
   (table) => [
-    sqliteCore.primaryKey({ columns: [table.tenantId, table.projectId, table.graphId, table.id] }),
+    sqliteCore.primaryKey({ columns: [table.tenantId, table.projectId, table.agentId, table.id] }),
     sqliteCore.foreignKey({
-      columns: [table.tenantId, table.projectId, table.graphId],
-      foreignColumns: [agentGraph.tenantId, agentGraph.projectId, agentGraph.id],
-      name: "agents_graph_fk"
+      columns: [table.tenantId, table.projectId, table.agentId],
+      foreignColumns: [agents.tenantId, agents.projectId, agents.id],
+      name: "sub_agents_agents_fk"
     }).onDelete("cascade")
   ]
 );
 var subAgentRelations = sqliteCore.sqliteTable(
   "sub_agent_relations",
   {
-    ...graphScoped,
+    ...agentScoped,
     sourceSubAgentId: sqliteCore.text("source_sub_agent_id").notNull(),
     // For internal relationships
     targetSubAgentId: sqliteCore.text("target_sub_agent_id"),
@@ -213628,31 +213616,30 @@ var subAgentRelations = sqliteCore.sqliteTable(
     ...timestamps
   },
   (table) => [
-    sqliteCore.primaryKey({ columns: [table.tenantId, table.projectId, table.graphId, table.id] }),
+    sqliteCore.primaryKey({ columns: [table.tenantId, table.projectId, table.agentId, table.id] }),
     sqliteCore.foreignKey({
-      columns: [table.tenantId, table.projectId, table.graphId],
-      foreignColumns: [agentGraph.tenantId, agentGraph.projectId, agentGraph.id],
-      name: "sub_agent_relations_graph_fk"
+      columns: [table.tenantId, table.projectId, table.agentId],
+      foreignColumns: [agents.tenantId, agents.projectId, agents.id],
+      name: "sub_agent_relations_agent_fk"
     }).onDelete("cascade")
   ]
 );
 var externalAgents = sqliteCore.sqliteTable(
   "external_agents",
   {
-    ...graphScoped,
+    ...agentScoped,
     ...uiProperties,
     baseUrl: sqliteCore.text("base_url").notNull(),
-    // A2A endpoint URL
     credentialReferenceId: sqliteCore.text("credential_reference_id"),
     headers: sqliteCore.blob("headers", { mode: "json" }).$type(),
     ...timestamps
   },
   (table) => [
-    sqliteCore.primaryKey({ columns: [table.tenantId, table.projectId, table.graphId, table.id] }),
+    sqliteCore.primaryKey({ columns: [table.tenantId, table.projectId, table.agentId, table.id] }),
     sqliteCore.foreignKey({
-      columns: [table.tenantId, table.projectId, table.graphId],
-      foreignColumns: [agentGraph.tenantId, agentGraph.projectId, agentGraph.id],
-      name: "external_agents_graph_fk"
+      columns: [table.tenantId, table.projectId, table.agentId],
+      foreignColumns: [agents.tenantId, agents.projectId, agents.id],
+      name: "external_agents_agent_fk"
     }).onDelete("cascade"),
     sqliteCore.foreignKey({
       columns: [table.tenantId, table.projectId, table.credentialReferenceId],
@@ -213677,8 +213664,8 @@ var tasks = sqliteCore.sqliteTable(
   (table) => [
     sqliteCore.primaryKey({ columns: [table.tenantId, table.projectId, table.id] }),
     sqliteCore.foreignKey({
-      columns: [table.tenantId, table.projectId, table.graphId, table.subAgentId],
-      foreignColumns: [subAgents.tenantId, subAgents.projectId, subAgents.graphId, subAgents.id],
+      columns: [table.tenantId, table.projectId, table.agentId, table.subAgentId],
+      foreignColumns: [subAgents.tenantId, subAgents.projectId, subAgents.agentId, subAgents.id],
       name: "tasks_sub_agent_fk"
     }).onDelete("cascade")
   ]
@@ -213690,7 +213677,6 @@ var taskRelations = sqliteCore.sqliteTable(
     parentTaskId: sqliteCore.text("parent_task_id").notNull(),
     childTaskId: sqliteCore.text("child_task_id").notNull(),
     relationType: sqliteCore.text("relation_type").default("parent_child"),
-    // Could be extended for other relation types
     ...timestamps
   },
   (table) => [
@@ -213728,13 +213714,11 @@ var subAgentDataComponents = sqliteCore.sqliteTable(
   },
   (table) => [
     sqliteCore.primaryKey({ columns: [table.tenantId, table.projectId, table.id] }),
-    // Foreign key constraint to agents table (ensures graph and project exist via cascade)
     sqliteCore.foreignKey({
-      columns: [table.tenantId, table.projectId, table.graphId, table.subAgentId],
-      foreignColumns: [subAgents.tenantId, subAgents.projectId, subAgents.graphId, subAgents.id],
+      columns: [table.tenantId, table.projectId, table.agentId, table.subAgentId],
+      foreignColumns: [subAgents.tenantId, subAgents.projectId, subAgents.agentId, subAgents.id],
       name: "sub_agent_data_components_sub_agent_fk"
     }).onDelete("cascade"),
-    // Foreign key constraint to data_components table
     sqliteCore.foreignKey({
       columns: [table.tenantId, table.projectId, table.dataComponentId],
       foreignColumns: [dataComponents.tenantId, dataComponents.projectId, dataComponents.id],
@@ -213768,15 +213752,13 @@ var subAgentArtifactComponents = sqliteCore.sqliteTable(
   },
   (table) => [
     sqliteCore.primaryKey({
-      columns: [table.tenantId, table.projectId, table.graphId, table.subAgentId, table.id]
+      columns: [table.tenantId, table.projectId, table.agentId, table.subAgentId, table.id]
     }),
-    // Foreign key constraint to agents table (ensures graph and project exist via cascade)
     sqliteCore.foreignKey({
-      columns: [table.tenantId, table.projectId, table.graphId, table.subAgentId],
-      foreignColumns: [subAgents.tenantId, subAgents.projectId, subAgents.graphId, subAgents.id],
+      columns: [table.tenantId, table.projectId, table.agentId, table.subAgentId],
+      foreignColumns: [subAgents.tenantId, subAgents.projectId, subAgents.agentId, subAgents.id],
       name: "sub_agent_artifact_components_sub_agent_fk"
     }).onDelete("cascade"),
-    // Foreign key constraint to artifact_components table
     sqliteCore.foreignKey({
       columns: [table.tenantId, table.projectId, table.artifactComponentId],
       foreignColumns: [
@@ -213816,18 +213798,18 @@ var tools = sqliteCore.sqliteTable(
 var functionTools = sqliteCore.sqliteTable(
   "function_tools",
   {
-    ...graphScoped,
+    ...agentScoped,
     name: sqliteCore.text("name").notNull(),
     description: sqliteCore.text("description"),
     functionId: sqliteCore.text("function_id").notNull(),
     ...timestamps
   },
   (table) => [
-    sqliteCore.primaryKey({ columns: [table.tenantId, table.projectId, table.graphId, table.id] }),
+    sqliteCore.primaryKey({ columns: [table.tenantId, table.projectId, table.agentId, table.id] }),
     sqliteCore.foreignKey({
-      columns: [table.tenantId, table.projectId, table.graphId],
-      foreignColumns: [agentGraph.tenantId, agentGraph.projectId, agentGraph.id],
-      name: "function_tools_graph_fk"
+      columns: [table.tenantId, table.projectId, table.agentId],
+      foreignColumns: [agents.tenantId, agents.projectId, agents.id],
+      name: "function_tools_agent_fk"
     }).onDelete("cascade"),
     // Foreign key constraint to functions table
     sqliteCore.foreignKey({
@@ -213865,14 +213847,12 @@ var subAgentToolRelations = sqliteCore.sqliteTable(
     ...timestamps
   },
   (table) => [
-    sqliteCore.primaryKey({ columns: [table.tenantId, table.projectId, table.graphId, table.id] }),
-    // Foreign key constraint to agents table (which includes project and graph scope)
+    sqliteCore.primaryKey({ columns: [table.tenantId, table.projectId, table.agentId, table.id] }),
     sqliteCore.foreignKey({
-      columns: [table.tenantId, table.projectId, table.graphId, table.subAgentId],
-      foreignColumns: [subAgents.tenantId, subAgents.projectId, subAgents.graphId, subAgents.id],
+      columns: [table.tenantId, table.projectId, table.agentId, table.subAgentId],
+      foreignColumns: [subAgents.tenantId, subAgents.projectId, subAgents.agentId, subAgents.id],
       name: "sub_agent_tool_relations_agent_fk"
     }).onDelete("cascade"),
-    // Foreign key constraint to tools table (MCP tools)
     sqliteCore.foreignKey({
       columns: [table.tenantId, table.projectId, table.toolId],
       foreignColumns: [tools.tenantId, tools.projectId, tools.id],
@@ -213888,20 +213868,20 @@ var agentFunctionToolRelations = sqliteCore.sqliteTable(
     ...timestamps
   },
   (table) => [
-    sqliteCore.primaryKey({ columns: [table.tenantId, table.projectId, table.graphId, table.id] }),
+    sqliteCore.primaryKey({ columns: [table.tenantId, table.projectId, table.agentId, table.id] }),
     // Foreign key constraint to agents table
     sqliteCore.foreignKey({
-      columns: [table.tenantId, table.projectId, table.graphId, table.subAgentId],
-      foreignColumns: [subAgents.tenantId, subAgents.projectId, subAgents.graphId, subAgents.id],
+      columns: [table.tenantId, table.projectId, table.agentId, table.subAgentId],
+      foreignColumns: [subAgents.tenantId, subAgents.projectId, subAgents.agentId, subAgents.id],
       name: "agent_function_tool_relations_agent_fk"
     }).onDelete("cascade"),
     // Foreign key constraint to functionTools table
     sqliteCore.foreignKey({
-      columns: [table.tenantId, table.projectId, table.graphId, table.functionToolId],
+      columns: [table.tenantId, table.projectId, table.agentId, table.functionToolId],
       foreignColumns: [
         functionTools.tenantId,
         functionTools.projectId,
-        functionTools.graphId,
+        functionTools.agentId,
         functionTools.id
       ],
       name: "agent_function_tool_relations_function_tool_fk"
@@ -213935,33 +213915,23 @@ var messages = sqliteCore.sqliteTable(
     conversationId: sqliteCore.text("conversation_id").notNull(),
     // Role mapping: user, agent, system (unified for both formats)
     role: sqliteCore.text("role").notNull(),
-    // 'user' | 'agent' | 'system'
     // Agent sender/recipient tracking (nullable - only populated when relevant)
     fromSubAgentId: sqliteCore.text("from_sub_agent_id"),
-    // Populated when message is from an agent
     toSubAgentId: sqliteCore.text("to_sub_agent_id"),
-    // Populated when message is directed to a specific agent (e.g., transfers/delegations)
     // External agent sender tracking
     fromExternalAgentId: sqliteCore.text("from_external_sub_agent_id"),
-    // Populated when message is directed from an external agent
     // External agent recipient tracking
     toExternalAgentId: sqliteCore.text("to_external_sub_agent_id"),
-    // Populated when message is directed to an external agent
     // Message content stored as JSON to support both formats
     content: sqliteCore.blob("content", { mode: "json" }).$type().notNull(),
     // Message classification and filtering
     visibility: sqliteCore.text("visibility").notNull().default("user-facing"),
-    // 'user-facing' | 'internal' | 'system' | 'external'
     messageType: sqliteCore.text("message_type").notNull().default("chat"),
-    // 'chat' | 'a2a-request' | 'a2a-response' | 'task-update' | 'tool-call'
     taskId: sqliteCore.text("task_id"),
     parentMessageId: sqliteCore.text("parent_message_id"),
-    // Remove self-reference constraint here
     // A2A specific fields
     a2aTaskId: sqliteCore.text("a2a_task_id"),
-    // Links to A2A task when relevant
     a2aSessionId: sqliteCore.text("a2a_session_id"),
-    // A2A session identifier
     // Metadata for extensions
     metadata: sqliteCore.blob("metadata", { mode: "json" }).$type(),
     ...timestamps
@@ -213982,7 +213952,6 @@ var ledgerArtifacts = sqliteCore.sqliteTable(
     // Links
     taskId: sqliteCore.text("task_id").notNull(),
     toolCallId: sqliteCore.text("tool_call_id"),
-    // Added for traceability to the specific tool execution
     contextId: sqliteCore.text("context_id").notNull(),
     // Core Artifact fields
     type: sqliteCore.text("type").notNull().default("source"),
@@ -214018,13 +213987,10 @@ var ledgerArtifacts = sqliteCore.sqliteTable(
 var apiKeys = sqliteCore.sqliteTable(
   "api_keys",
   {
-    ...graphScoped,
+    ...agentScoped,
     publicId: sqliteCore.text("public_id").notNull().unique(),
-    // Public ID for O(1) lookup (e.g., "abc123def456")
     keyHash: sqliteCore.text("key_hash").notNull(),
-    // Hashed API key (never store plaintext)
     keyPrefix: sqliteCore.text("key_prefix").notNull(),
-    // First 8 chars for identification (e.g., "sk_live_abc...")
     name: sqliteCore.text("name"),
     lastUsedAt: sqliteCore.text("last_used_at"),
     expiresAt: sqliteCore.text("expires_at"),
@@ -214037,11 +214003,11 @@ var apiKeys = sqliteCore.sqliteTable(
       name: "api_keys_project_fk"
     }).onDelete("cascade"),
     sqliteCore.foreignKey({
-      columns: [t.tenantId, t.projectId, t.graphId],
-      foreignColumns: [agentGraph.tenantId, agentGraph.projectId, agentGraph.id],
-      name: "api_keys_graph_fk"
+      columns: [t.tenantId, t.projectId, t.agentId],
+      foreignColumns: [agents.tenantId, agents.projectId, agents.id],
+      name: "api_keys_agent_fk"
     }).onDelete("cascade"),
-    sqliteCore.index("api_keys_tenant_graph_idx").on(t.tenantId, t.graphId),
+    sqliteCore.index("api_keys_tenant_agent_idx").on(t.tenantId, t.agentId),
     sqliteCore.index("api_keys_prefix_idx").on(t.keyPrefix),
     sqliteCore.index("api_keys_public_id_idx").on(t.publicId)
   ]
@@ -214051,9 +214017,7 @@ var credentialReferences = sqliteCore.sqliteTable(
   {
     ...projectScoped,
     type: sqliteCore.text("type").notNull(),
-    // Implementation type: 'keychain', 'nango', 'memory', etc.
     credentialStoreId: sqliteCore.text("credential_store_id").notNull(),
-    // Maps to framework.getCredentialStore(id)
     retrievalParams: sqliteCore.blob("retrieval_params", { mode: "json" }).$type(),
     ...timestamps
   },
@@ -214067,7 +214031,6 @@ var credentialReferences = sqliteCore.sqliteTable(
   ]
 );
 var tasksRelations = drizzleOrm.relations(tasks, ({ one, many }) => ({
-  // A task belongs to one project
   project: one(projects, {
     fields: [tasks.tenantId, tasks.projectId],
     references: [projects.tenantId, projects.id]
@@ -214084,14 +214047,12 @@ var tasksRelations = drizzleOrm.relations(tasks, ({ one, many }) => ({
     fields: [tasks.subAgentId],
     references: [subAgents.id]
   }),
-  // A task can have many messages associated with it
   messages: many(messages),
-  // A task can have many ledger artifacts
   ledgerArtifacts: many(ledgerArtifacts)
 }));
 var projectsRelations = drizzleOrm.relations(projects, ({ many }) => ({
   subAgents: many(subAgents),
-  agentGraphs: many(agentGraph),
+  agents: many(agents),
   tools: many(tools),
   functions: many(functions),
   contextConfigs: many(contextConfigs),
@@ -214120,7 +214081,7 @@ var contextConfigsRelations = drizzleOrm.relations(contextConfigs, ({ many, one
     fields: [contextConfigs.tenantId, contextConfigs.projectId],
     references: [projects.tenantId, projects.id]
   }),
-  graphs: many(agentGraph),
+  agents: many(agents),
   cache: many(contextCache)
 }));
 var contextCacheRelations = drizzleOrm.relations(contextCache, ({ one }) => ({
@@ -214135,7 +214096,7 @@ var subAgentsRelations = drizzleOrm.relations(subAgents, ({ many, one }) => ({
     references: [projects.tenantId, projects.id]
   }),
   tasks: many(tasks),
-  defaultForGraphs: many(agentGraph),
+  defaultForAgents: many(agents),
   sourceRelations: many(subAgentRelations, {
     relationName: "sourceRelations"
   }),
@@ -214148,25 +214109,22 @@ var subAgentsRelations = drizzleOrm.relations(subAgents, ({ many, one }) => ({
   receivedMessages: many(messages, {
     relationName: "receivedMessages"
   }),
-  associatedMessages: many(messages, {
-    relationName: "associatedAgent"
-  }),
   toolRelations: many(subAgentToolRelations),
   functionToolRelations: many(agentFunctionToolRelations),
   dataComponentRelations: many(subAgentDataComponents),
   artifactComponentRelations: many(subAgentArtifactComponents)
 }));
-var agentGraphRelations = drizzleOrm.relations(agentGraph, ({ one, many }) => ({
+var agentRelations = drizzleOrm.relations(agents, ({ one, many }) => ({
   project: one(projects, {
-    fields: [agentGraph.tenantId, agentGraph.projectId],
+    fields: [agents.tenantId, agents.projectId],
     references: [projects.tenantId, projects.id]
   }),
   defaultSubAgent: one(subAgents, {
-    fields: [agentGraph.defaultSubAgentId],
+    fields: [agents.defaultSubAgentId],
     references: [subAgents.id]
   }),
   contextConfig: one(contextConfigs, {
-    fields: [agentGraph.contextConfigId],
+    fields: [agents.contextConfigId],
     references: [contextConfigs.id]
   }),
   functionTools: many(functionTools)
@@ -214187,9 +214145,9 @@ var apiKeysRelations = drizzleOrm.relations(apiKeys, ({ one }) => ({
     fields: [apiKeys.tenantId, apiKeys.projectId],
     references: [projects.tenantId, projects.id]
   }),
-  graph: one(agentGraph, {
-    fields: [apiKeys.graphId],
-    references: [agentGraph.id]
+  agent: one(agents, {
+    fields: [apiKeys.agentId],
+    references: [agents.id]
   })
 }));
 var agentToolRelationsRelations = drizzleOrm.relations(subAgentToolRelations, ({ one }) => ({
@@ -214202,8 +214160,13 @@ var agentToolRelationsRelations = drizzleOrm.relations(subAgentToolRelations, ({
     references: [tools.id]
   })
 }));
-var credentialReferencesRelations = drizzleOrm.relations(credentialReferences, ({ many }) => ({
-  tools: many(tools)
+var credentialReferencesRelations = drizzleOrm.relations(credentialReferences, ({ one, many }) => ({
+  project: one(projects, {
+    fields: [credentialReferences.tenantId, credentialReferences.projectId],
+    references: [projects.tenantId, projects.id]
+  }),
+  tools: many(tools),
+  externalAgents: many(externalAgents)
 }));
 var toolsRelations = drizzleOrm.relations(tools, ({ one, many }) => ({
   project: one(projects, {
@@ -214312,13 +214275,17 @@ var ledgerArtifactsRelations = drizzleOrm.relations(ledgerArtifacts, ({ one }) =
     references: [tasks.id]
   })
 }));
-var functionsRelations = drizzleOrm.relations(functions, ({ many }) => ({
-  functionTools: many(functionTools)
+var functionsRelations = drizzleOrm.relations(functions, ({ many, one }) => ({
+  functionTools: many(functionTools),
+  project: one(projects, {
+    fields: [functions.tenantId, functions.projectId],
+    references: [projects.tenantId, projects.id]
+  })
 }));
 var subAgentRelationsRelations = drizzleOrm.relations(subAgentRelations, ({ one }) => ({
-  graph: one(agentGraph, {
-    fields: [subAgentRelations.graphId],
-    references: [agentGraph.id]
+  agent: one(agents, {
+    fields: [subAgentRelations.agentId],
+    references: [agents.id]
   }),
   sourceSubAgent: one(subAgents, {
     fields: [subAgentRelations.sourceSubAgentId],
@@ -214340,9 +214307,9 @@ var functionToolsRelations = drizzleOrm.relations(functionTools, ({ one, many })
     fields: [functionTools.tenantId, functionTools.projectId],
     references: [projects.tenantId, projects.id]
   }),
-  graph: one(agentGraph, {
-    fields: [functionTools.tenantId, functionTools.projectId, functionTools.graphId],
-    references: [agentGraph.tenantId, agentGraph.projectId, agentGraph.id]
+  agent: one(agents, {
+    fields: [functionTools.tenantId, functionTools.projectId, functionTools.agentId],
+    references: [agents.tenantId, agents.projectId, agents.id]
   }),
   function: one(functions, {
     fields: [functionTools.tenantId, functionTools.projectId, functionTools.functionId],
@@ -214386,7 +214353,7 @@ var StopWhenSchema = zodOpenapi.z.object({
   transferCountIs: zodOpenapi.z.number().min(1).max(100).optional(),
   stepCountIs: zodOpenapi.z.number().min(1).max(1e3).optional()
 });
-var GraphStopWhenSchema = StopWhenSchema.pick({ transferCountIs: true });
+var AgentStopWhenSchema = StopWhenSchema.pick({ transferCountIs: true });
 var SubAgentStopWhenSchema = StopWhenSchema.pick({ stepCountIs: true });
 var MIN_ID_LENGTH = 1;
 var MAX_ID_LENGTH = 255;
@@ -214427,31 +214394,31 @@ var FunctionToolConfigSchema = zodOpenapi.z.object({
 var createApiSchema = (schema) => schema.omit({ tenantId: true, projectId: true });
 var createApiInsertSchema = (schema) => schema.omit({ tenantId: true, projectId: true });
 var createApiUpdateSchema = (schema) => schema.omit({ tenantId: true, projectId: true }).partial();
-var createGraphScopedApiSchema = (schema) => schema.omit({ tenantId: true, projectId: true, graphId: true });
-var createGraphScopedApiInsertSchema = (schema) => schema.omit({ tenantId: true, projectId: true, graphId: true });
-var createGraphScopedApiUpdateSchema = (schema) => schema.omit({ tenantId: true, projectId: true, graphId: true }).partial();
+var createAgentScopedApiSchema = (schema) => schema.omit({ tenantId: true, projectId: true, agentId: true });
+var createAgentScopedApiInsertSchema = (schema) => schema.omit({ tenantId: true, projectId: true, agentId: true });
+var createAgentScopedApiUpdateSchema = (schema) => schema.omit({ tenantId: true, projectId: true, agentId: true }).partial();
 var SubAgentSelectSchema = drizzleZod.createSelectSchema(subAgents);
 var SubAgentInsertSchema = drizzleZod.createInsertSchema(subAgents).extend({
   id: resourceIdSchema,
   models: ModelSchema.optional()
 });
 var SubAgentUpdateSchema = SubAgentInsertSchema.partial();
-var SubAgentApiSelectSchema = createGraphScopedApiSchema(SubAgentSelectSchema);
-var SubAgentApiInsertSchema = createGraphScopedApiInsertSchema(SubAgentInsertSchema);
-var SubAgentApiUpdateSchema = createGraphScopedApiUpdateSchema(SubAgentUpdateSchema);
+var SubAgentApiSelectSchema = createAgentScopedApiSchema(SubAgentSelectSchema);
+var SubAgentApiInsertSchema = createAgentScopedApiInsertSchema(SubAgentInsertSchema);
+var SubAgentApiUpdateSchema = createAgentScopedApiUpdateSchema(SubAgentUpdateSchema);
 var SubAgentRelationSelectSchema = drizzleZod.createSelectSchema(subAgentRelations);
 var SubAgentRelationInsertSchema = drizzleZod.createInsertSchema(subAgentRelations).extend({
   id: resourceIdSchema,
-  graphId: resourceIdSchema,
+  agentId: resourceIdSchema,
   sourceSubAgentId: resourceIdSchema,
   targetSubAgentId: resourceIdSchema.optional(),
   externalSubAgentId: resourceIdSchema.optional()
 });
 var SubAgentRelationUpdateSchema = SubAgentRelationInsertSchema.partial();
-var SubAgentRelationApiSelectSchema = createGraphScopedApiSchema(
+var SubAgentRelationApiSelectSchema = createAgentScopedApiSchema(
   SubAgentRelationSelectSchema
 );
-var SubAgentRelationApiInsertSchema = createGraphScopedApiInsertSchema(
+var SubAgentRelationApiInsertSchema = createAgentScopedApiInsertSchema(
   SubAgentRelationInsertSchema
 ).extend({
   relationType: zodOpenapi.z.enum(VALID_RELATION_TYPES)
@@ -214466,7 +214433,7 @@ var SubAgentRelationApiInsertSchema = createGraphScopedApiInsertSchema(
     path: ["targetSubAgentId", "externalSubAgentId"]
   }
 );
-var SubAgentRelationApiUpdateSchema = createGraphScopedApiUpdateSchema(
+var SubAgentRelationApiUpdateSchema = createAgentScopedApiUpdateSchema(
   SubAgentRelationUpdateSchema
 ).extend({
   relationType: zodOpenapi.z.enum(VALID_RELATION_TYPES).optional()
@@ -214491,23 +214458,23 @@ var SubAgentRelationQuerySchema = zodOpenapi.z.object({
 });
 var ExternalSubAgentRelationInsertSchema = drizzleZod.createInsertSchema(subAgentRelations).extend({
   id: resourceIdSchema,
-  graphId: resourceIdSchema,
+  agentId: resourceIdSchema,
   sourceSubAgentId: resourceIdSchema,
   externalSubAgentId: resourceIdSchema
 });
 var ExternalSubAgentRelationApiInsertSchema = createApiInsertSchema(
   ExternalSubAgentRelationInsertSchema
 );
-var AgentGraphSelectSchema = drizzleZod.createSelectSchema(agentGraph);
-var AgentGraphInsertSchema = drizzleZod.createInsertSchema(agentGraph).extend({
+var AgentSelectSchema = drizzleZod.createSelectSchema(agents);
+var AgentInsertSchema = drizzleZod.createInsertSchema(agents).extend({
   id: resourceIdSchema
 });
-var AgentGraphUpdateSchema = AgentGraphInsertSchema.partial();
-var AgentGraphApiSelectSchema = createApiSchema(AgentGraphSelectSchema);
-var AgentGraphApiInsertSchema = createApiInsertSchema(AgentGraphInsertSchema).extend({
+var AgentUpdateSchema = AgentInsertSchema.partial();
+var AgentApiSelectSchema = createApiSchema(AgentSelectSchema);
+var AgentApiInsertSchema = createApiInsertSchema(AgentInsertSchema).extend({
   id: resourceIdSchema
 });
-var AgentGraphApiUpdateSchema = createApiUpdateSchema(AgentGraphUpdateSchema);
+var AgentApiUpdateSchema = createApiUpdateSchema(AgentUpdateSchema);
 var TaskSelectSchema = drizzleZod.createSelectSchema(tasks);
 var TaskInsertSchema = drizzleZod.createInsertSchema(tasks).extend({
   id: resourceIdSchema,
@@ -214550,7 +214517,10 @@ var McpTransportConfigSchema = zodOpenapi.z.object({
   type: zodOpenapi.z.enum(MCPTransportType),
   requestInit: zodOpenapi.z.record(zodOpenapi.z.string(), zodOpenapi.z.unknown()).optional(),
   eventSourceInit: zodOpenapi.z.record(zodOpenapi.z.string(), zodOpenapi.z.unknown()).optional(),
-  reconnectionOptions: zodOpenapi.z.custom().optional(),
+  reconnectionOptions: zodOpenapi.z.any().optional().openapi({
+    type: "object",
+    description: "Reconnection options for streamable HTTP transport"
+  }),
   sessionId: zodOpenapi.z.string().optional()
 });
 var ToolStatusSchema = zodOpenapi.z.enum(TOOL_STATUS_VALUES);
@@ -214567,13 +214537,16 @@ var ToolInsertSchema = drizzleZod.createInsertSchema(tools).extend({
     type: zodOpenapi.z.literal("mcp"),
     mcp: zodOpenapi.z.object({
       server: zodOpenapi.z.object({
-        url: zodOpenapi.z.string().url()
+        url: zodOpenapi.z.url()
       }),
       transport: zodOpenapi.z.object({
         type: zodOpenapi.z.enum(MCPTransportType),
         requestInit: zodOpenapi.z.record(zodOpenapi.z.string(), zodOpenapi.z.unknown()).optional(),
         eventSourceInit: zodOpenapi.z.record(zodOpenapi.z.string(), zodOpenapi.z.unknown()).optional(),
-        reconnectionOptions: zodOpenapi.z.custom().optional(),
+        reconnectionOptions: zodOpenapi.z.any().optional().openapi({
+          type: "object",
+          description: "Reconnection options for streamable HTTP transport"
+        }),
         sessionId: zodOpenapi.z.string().optional()
       }).optional(),
       activeTools: zodOpenapi.z.array(zodOpenapi.z.string()).optional()
@@ -214620,7 +214593,7 @@ var DataComponentApiUpdateSchema = createApiUpdateSchema(DataComponentUpdateSche
 var SubAgentDataComponentSelectSchema = drizzleZod.createSelectSchema(subAgentDataComponents);
 var SubAgentDataComponentInsertSchema = drizzleZod.createInsertSchema(subAgentDataComponents);
 var SubAgentDataComponentUpdateSchema = SubAgentDataComponentInsertSchema.partial();
-var SubAgentDataComponentApiSelectSchema = createGraphScopedApiSchema(
+var SubAgentDataComponentApiSelectSchema = createAgentScopedApiSchema(
   SubAgentDataComponentSelectSchema
 );
 var SubAgentDataComponentApiInsertSchema = SubAgentDataComponentInsertSchema.omit({
@@ -214629,7 +214602,7 @@ var SubAgentDataComponentApiInsertSchema = SubAgentDataComponentInsertSchema.omi
   id: true,
   createdAt: true
 });
-var SubAgentDataComponentApiUpdateSchema = createGraphScopedApiUpdateSchema(
+var SubAgentDataComponentApiUpdateSchema = createAgentScopedApiUpdateSchema(
   SubAgentDataComponentUpdateSchema
 );
 var ArtifactComponentSelectSchema = drizzleZod.createSelectSchema(artifactComponents);
@@ -214656,7 +214629,7 @@ var SubAgentArtifactComponentInsertSchema = drizzleZod.createInsertSchema(
   artifactComponentId: resourceIdSchema
 });
 var SubAgentArtifactComponentUpdateSchema = SubAgentArtifactComponentInsertSchema.partial();
-var SubAgentArtifactComponentApiSelectSchema = createGraphScopedApiSchema(
+var SubAgentArtifactComponentApiSelectSchema = createAgentScopedApiSchema(
   SubAgentArtifactComponentSelectSchema
 );
 var SubAgentArtifactComponentApiInsertSchema = SubAgentArtifactComponentInsertSchema.omit({
@@ -214665,7 +214638,7 @@ var SubAgentArtifactComponentApiInsertSchema = SubAgentArtifactComponentInsertSc
   id: true,
   createdAt: true
 });
-var SubAgentArtifactComponentApiUpdateSchema = createGraphScopedApiUpdateSchema(
+var SubAgentArtifactComponentApiUpdateSchema = createAgentScopedApiUpdateSchema(
   SubAgentArtifactComponentUpdateSchema
 );
 var ExternalAgentSelectSchema = drizzleZod.createSelectSchema(externalAgents).extend({
@@ -214676,9 +214649,9 @@ var ExternalAgentInsertSchema = drizzleZod.createInsertSchema(externalAgents).ex
   id: resourceIdSchema
 });
 var ExternalAgentUpdateSchema = ExternalAgentInsertSchema.partial();
-var ExternalAgentApiSelectSchema = createGraphScopedApiSchema(ExternalAgentSelectSchema);
-var ExternalAgentApiInsertSchema = createGraphScopedApiInsertSchema(ExternalAgentInsertSchema);
-var ExternalAgentApiUpdateSchema = createGraphScopedApiUpdateSchema(ExternalAgentUpdateSchema);
+var ExternalAgentApiSelectSchema = createAgentScopedApiSchema(ExternalAgentSelectSchema);
+var ExternalAgentApiInsertSchema = createAgentScopedApiInsertSchema(ExternalAgentInsertSchema);
+var ExternalAgentApiUpdateSchema = createAgentScopedApiUpdateSchema(ExternalAgentUpdateSchema);
 var AllAgentSchema = zodOpenapi.z.discriminatedUnion("type", [
   SubAgentApiSelectSchema.extend({ type: zodOpenapi.z.literal("internal") }),
   ExternalAgentApiSelectSchema.extend({ type: zodOpenapi.z.literal("external") })
@@ -214686,7 +214659,7 @@ var AllAgentSchema = zodOpenapi.z.discriminatedUnion("type", [
 var ApiKeySelectSchema = drizzleZod.createSelectSchema(apiKeys);
 var ApiKeyInsertSchema = drizzleZod.createInsertSchema(apiKeys).extend({
   id: resourceIdSchema,
-  graphId: resourceIdSchema
+  agentId: resourceIdSchema
 });
 var ApiKeyUpdateSchema = ApiKeyInsertSchema.partial().omit({
   tenantId: true,
@@ -214794,7 +214767,7 @@ var FunctionToolInsertSchema = drizzleZod.createInsertSchema(functionTools).exte
 });
 var FunctionToolUpdateSchema = FunctionToolInsertSchema.partial();
 var FunctionToolApiSelectSchema = createApiSchema(FunctionToolSelectSchema);
-var FunctionToolApiInsertSchema = createGraphScopedApiInsertSchema(FunctionToolInsertSchema);
+var FunctionToolApiInsertSchema = createAgentScopedApiInsertSchema(FunctionToolInsertSchema);
 var FunctionToolApiUpdateSchema = createApiUpdateSchema(FunctionToolUpdateSchema);
 var FunctionSelectSchema = drizzleZod.createSelectSchema(functions);
 var FunctionInsertSchema = drizzleZod.createInsertSchema(functions).extend({
@@ -214820,28 +214793,40 @@ var FetchDefinitionSchema = zodOpenapi.z.object({
   fetchConfig: FetchConfigSchema,
   responseSchema: zodOpenapi.z.any().optional(),
   // JSON Schema for validating HTTP response
-  defaultValue: zodOpenapi.z.unknown().optional(),
+  defaultValue: zodOpenapi.z.any().optional().openapi({
+    description: "Default value if fetch fails"
+  }),
   credential: CredentialReferenceApiInsertSchema.optional()
 });
 var ContextConfigSelectSchema = drizzleZod.createSelectSchema(contextConfigs).extend({
-  headersSchema: zodOpenapi.z.unknown().optional()
+  headersSchema: zodOpenapi.z.any().optional().openapi({
+    type: "object",
+    description: "JSON Schema for validating request headers"
+  })
 });
 var ContextConfigInsertSchema = drizzleZod.createInsertSchema(contextConfigs).extend({
   id: resourceIdSchema.optional(),
-  headersSchema: zodOpenapi.z.unknown().optional()
+  headersSchema: zodOpenapi.z.any().nullable().optional().openapi({
+    type: "object",
+    description: "JSON Schema for validating request headers"
+  }),
+  contextVariables: zodOpenapi.z.any().nullable().optional().openapi({
+    type: "object",
+    description: "Context variables configuration with fetch definitions"
+  })
 }).omit({
   createdAt: true,
   updatedAt: true
 });
 var ContextConfigUpdateSchema = ContextConfigInsertSchema.partial();
 var ContextConfigApiSelectSchema = createApiSchema(ContextConfigSelectSchema).omit({
-  graphId: true
+  agentId: true
 });
 var ContextConfigApiInsertSchema = createApiInsertSchema(ContextConfigInsertSchema).omit({
-  graphId: true
+  agentId: true
 });
 var ContextConfigApiUpdateSchema = createApiUpdateSchema(ContextConfigUpdateSchema).omit({
-  graphId: true
+  agentId: true
 });
 var SubAgentToolRelationSelectSchema = drizzleZod.createSelectSchema(subAgentToolRelations);
 var SubAgentToolRelationInsertSchema = drizzleZod.createInsertSchema(subAgentToolRelations).extend({
@@ -214852,13 +214837,13 @@ var SubAgentToolRelationInsertSchema = drizzleZod.createInsertSchema(subAgentToo
   headers: zodOpenapi.z.record(zodOpenapi.z.string(), zodOpenapi.z.string()).nullish()
 });
 var SubAgentToolRelationUpdateSchema = SubAgentToolRelationInsertSchema.partial();
-var SubAgentToolRelationApiSelectSchema = createGraphScopedApiSchema(
+var SubAgentToolRelationApiSelectSchema = createAgentScopedApiSchema(
   SubAgentToolRelationSelectSchema
 );
-var SubAgentToolRelationApiInsertSchema = createGraphScopedApiInsertSchema(
+var SubAgentToolRelationApiInsertSchema = createAgentScopedApiInsertSchema(
   SubAgentToolRelationInsertSchema
 );
-var SubAgentToolRelationApiUpdateSchema = createGraphScopedApiUpdateSchema(
+var SubAgentToolRelationApiUpdateSchema = createAgentScopedApiUpdateSchema(
   SubAgentToolRelationUpdateSchema
 );
 var LedgerArtifactSelectSchema = drizzleZod.createSelectSchema(ledgerArtifacts);
@@ -214889,7 +214874,7 @@ var CanUseItemSchema = zodOpenapi.z.object({
   toolSelection: zodOpenapi.z.array(zodOpenapi.z.string()).nullish(),
   headers: zodOpenapi.z.record(zodOpenapi.z.string(), zodOpenapi.z.string()).nullish()
 });
-var FullGraphAgentInsertSchema = SubAgentApiInsertSchema.extend({
+var FullAgentAgentInsertSchema = SubAgentApiInsertSchema.extend({
   type: zodOpenapi.z.literal("internal"),
   canUse: zodOpenapi.z.array(CanUseItemSchema),
   // All tools (both MCP and function tools)
@@ -214898,44 +214883,23 @@ var FullGraphAgentInsertSchema = SubAgentApiInsertSchema.extend({
   canTransferTo: zodOpenapi.z.array(zodOpenapi.z.string()).optional(),
   canDelegateTo: zodOpenapi.z.array(zodOpenapi.z.string()).optional()
 });
-var FullGraphDefinitionSchema = AgentGraphApiInsertSchema.extend({
-  subAgents: zodOpenapi.z.record(
-    zodOpenapi.z.string(),
-    zodOpenapi.z.union([FullGraphAgentInsertSchema, ExternalAgentApiInsertSchema])
-  ),
-  // Lookup maps for UI to resolve canUse items
-  tools: zodOpenapi.z.record(zodOpenapi.z.string(), ToolApiInsertSchema).optional(),
-  // MCP tools (project-scoped)
-  functionTools: zodOpenapi.z.record(zodOpenapi.z.string(), FunctionToolApiInsertSchema).optional(),
-  // Function tools (graph-scoped)
-  functions: zodOpenapi.z.record(zodOpenapi.z.string(), FunctionApiInsertSchema).optional(),
-  // Get function code for function tools
-  contextConfig: zodOpenapi.z.optional(ContextConfigApiInsertSchema),
-  statusUpdates: zodOpenapi.z.optional(StatusUpdateSchema),
-  models: ModelSchema.optional(),
-  stopWhen: GraphStopWhenSchema.optional(),
-  graphPrompt: zodOpenapi.z.string().max(5e3, "Graph prompt cannot exceed 5000 characters").optional()
-});
-var GraphWithinContextOfProjectSchema = AgentGraphApiInsertSchema.extend({
+var AgentWithinContextOfProjectSchema = AgentApiInsertSchema.extend({
   subAgents: zodOpenapi.z.record(
     zodOpenapi.z.string(),
-    zodOpenapi.z.discriminatedUnion("type", [
-      FullGraphAgentInsertSchema,
-      ExternalAgentApiInsertSchema.extend({ type: zodOpenapi.z.literal("external") })
-    ])
+    zodOpenapi.z.union([FullAgentAgentInsertSchema, ExternalAgentApiInsertSchema])
   ),
   // Lookup maps for UI to resolve canUse items
   tools: zodOpenapi.z.record(zodOpenapi.z.string(), ToolApiInsertSchema).optional(),
   // MCP tools (project-scoped)
   functionTools: zodOpenapi.z.record(zodOpenapi.z.string(), FunctionToolApiInsertSchema).optional(),
-  // Function tools (graph-scoped)
+  // Function tools (agent-scoped)
   functions: zodOpenapi.z.record(zodOpenapi.z.string(), FunctionApiInsertSchema).optional(),
   // Get function code for function tools
   contextConfig: zodOpenapi.z.optional(ContextConfigApiInsertSchema),
   statusUpdates: zodOpenapi.z.optional(StatusUpdateSchema),
   models: ModelSchema.optional(),
-  stopWhen: GraphStopWhenSchema.optional(),
-  graphPrompt: zodOpenapi.z.string().max(5e3, "Graph prompt cannot exceed 5000 characters").optional()
+  stopWhen: AgentStopWhenSchema.optional(),
+  prompt: zodOpenapi.z.string().max(5e3, "Agent prompt cannot exceed 5000 characters").optional()
 });
 var PaginationSchema = zodOpenapi.z.object({
   page: zodOpenapi.z.coerce.number().min(1).default(1),
@@ -214953,7 +214917,9 @@ var SingleResponseSchema = (itemSchema) => zodOpenapi.z.object({
 var ErrorResponseSchema = zodOpenapi.z.object({
   error: zodOpenapi.z.string(),
   message: zodOpenapi.z.string().optional(),
-  details: zodOpenapi.z.unknown().optional()
+  details: zodOpenapi.z.any().optional().openapi({
+    description: "Additional error details"
+  })
 });
 var ExistsResponseSchema = zodOpenapi.z.object({
   exists: zodOpenapi.z.boolean()
@@ -214976,11 +214942,9 @@ var ProjectApiSelectSchema = ProjectSelectSchema.omit({ tenantId: true });
 var ProjectApiInsertSchema = ProjectInsertSchema.omit({ tenantId: true });
 var ProjectApiUpdateSchema = ProjectUpdateSchema.omit({ tenantId: true });
 var FullProjectDefinitionSchema = ProjectApiInsertSchema.extend({
-  graphs: zodOpenapi.z.record(zodOpenapi.z.string(), GraphWithinContextOfProjectSchema),
+  agents: zodOpenapi.z.record(zodOpenapi.z.string(), AgentWithinContextOfProjectSchema),
   tools: zodOpenapi.z.record(zodOpenapi.z.string(), ToolApiInsertSchema),
-  // MCP tools (project-scoped)
   functions: zodOpenapi.z.record(zodOpenapi.z.string(), FunctionApiInsertSchema).optional(),
-  // Functions (project-scoped)
   dataComponents: zodOpenapi.z.record(zodOpenapi.z.string(), DataComponentApiInsertSchema).optional(),
   artifactComponents: zodOpenapi.z.record(zodOpenapi.z.string(), ArtifactComponentApiInsertSchema).optional(),
   statusUpdates: zodOpenapi.z.optional(StatusUpdateSchema),
@@ -214997,9 +214961,9 @@ var HeadersScopeSchema = zodOpenapi.z.object({
     description: "Project identifier",
     example: "project_456"
   }),
-  "x-inkeep-graph-id": zodOpenapi.z.string().optional().openapi({
-    description: "Graph identifier",
-    example: "graph_789"
+  "x-inkeep-agent-id": zodOpenapi.z.string().optional().openapi({
+    description: "Agent identifier",
+    example: "agent_789"
   })
 });
 var TenantId = zodOpenapi.z.string().openapi({
@@ -215010,9 +214974,9 @@ var ProjectId = zodOpenapi.z.string().openapi({
   description: "Project identifier",
   example: "project_456"
 });
-var GraphId = zodOpenapi.z.string().openapi({
-  description: "Graph identifier",
-  example: "graph_789"
+var AgentId = zodOpenapi.z.string().openapi({
+  description: "Agent identifier",
+  example: "agent_789"
 });
 var SubAgentId = zodOpenapi.z.string().openapi({
   description: "Sub-agent identifier",
@@ -215030,18 +214994,18 @@ var TenantProjectParamsSchema = TenantParamsSchema.extend({
 var TenantProjectIdParamsSchema = TenantProjectParamsSchema.extend({
   id: resourceIdSchema
 }).openapi("TenantProjectIdParams");
-var TenantProjectGraphParamsSchema = TenantProjectParamsSchema.extend({
-  graphId: GraphId
-}).openapi("TenantProjectGraphParams");
-var TenantProjectGraphIdParamsSchema = TenantProjectGraphParamsSchema.extend({
+var TenantProjectAgentParamsSchema = TenantProjectParamsSchema.extend({
+  agentId: AgentId
+}).openapi("TenantProjectAgentParams");
+var TenantProjectAgentIdParamsSchema = TenantProjectAgentParamsSchema.extend({
   id: resourceIdSchema
-}).openapi("TenantProjectGraphIdParams");
-var TenantProjectGraphSubAgentParamsSchema = TenantProjectGraphParamsSchema.extend({
+}).openapi("TenantProjectAgentIdParams");
+var TenantProjectAgentSubAgentParamsSchema = TenantProjectAgentParamsSchema.extend({
   subAgentId: SubAgentId
-}).openapi("TenantProjectGraphSubAgentParams");
-var TenantProjectGraphSubAgentIdParamsSchema = TenantProjectGraphSubAgentParamsSchema.extend({
+}).openapi("TenantProjectAgentSubAgentParams");
+var TenantProjectAgentSubAgentIdParamsSchema = TenantProjectAgentSubAgentParamsSchema.extend({
   id: resourceIdSchema
-}).openapi("TenantProjectGraphSubAgentIdParams");
+}).openapi("TenantProjectAgentSubAgentIdParams");
 var PaginationQueryParamsSchema = zodOpenapi.z.object({
   page: zodOpenapi.z.coerce.number().min(1).default(1),
   limit: zodOpenapi.z.coerce.number().min(1).max(100).default(10)
@@ -215071,10 +215035,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) {
@@ -215123,23 +215087,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;
     logger2.info(
       {
         contextConfigId: this.config.id,
         tenantId: this.tenantId,
         projectId: this.projectId,
-        graphId: this.graphId
+        agentId: this.agentId
       },
       "ContextConfig context updated"
     );
@@ -215152,7 +215116,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(),
@@ -215243,7 +215207,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: {
@@ -215269,7 +215233,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: {
@@ -215764,7 +215728,7 @@ var getContextConfigById = (db) => async (params) => {
     where: drizzleOrm.and(
       drizzleOrm.eq(contextConfigs.tenantId, params.scopes.tenantId),
       drizzleOrm.eq(contextConfigs.projectId, params.scopes.projectId),
-      drizzleOrm.eq(contextConfigs.graphId, params.scopes.graphId),
+      drizzleOrm.eq(contextConfigs.agentId, params.scopes.agentId),
       drizzleOrm.eq(contextConfigs.id, params.id)
     )
   });
@@ -215774,7 +215738,7 @@ var listContextConfigs = (db) => async (params) => {
     where: drizzleOrm.and(
       drizzleOrm.eq(contextConfigs.tenantId, params.scopes.tenantId),
       drizzleOrm.eq(contextConfigs.projectId, params.scopes.projectId),
-      drizzleOrm.eq(contextConfigs.graphId, params.scopes.graphId)
+      drizzleOrm.eq(contextConfigs.agentId, params.scopes.agentId)
     ),
     orderBy: [drizzleOrm.desc(contextConfigs.createdAt)]
   });
@@ -215786,7 +215750,7 @@ var listContextConfigsPaginated = (db) => async (params) => {
   const whereClause = drizzleOrm.and(
     drizzleOrm.eq(contextConfigs.tenantId, params.scopes.tenantId),
     drizzleOrm.eq(contextConfigs.projectId, params.scopes.projectId),
-    drizzleOrm.eq(contextConfigs.graphId, params.scopes.graphId)
+    drizzleOrm.eq(contextConfigs.agentId, params.scopes.agentId)
   );
   const [contextConfigList, totalResult] = await Promise.all([
     db.select().from(contextConfigs).where(whereClause).limit(limit).offset(offset).orderBy(drizzleOrm.desc(contextConfigs.createdAt)),
@@ -215815,7 +215779,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,
@@ -215841,7 +215805,7 @@ var updateContextConfig = (db) => async (params) => {
     drizzleOrm.and(
       drizzleOrm.eq(contextConfigs.tenantId, params.scopes.tenantId),
       drizzleOrm.eq(contextConfigs.projectId, params.scopes.projectId),
-      drizzleOrm.eq(contextConfigs.graphId, params.scopes.graphId),
+      drizzleOrm.eq(contextConfigs.agentId, params.scopes.agentId),
       drizzleOrm.eq(contextConfigs.id, params.id)
     )
   ).returning();
@@ -215853,7 +215817,7 @@ var deleteContextConfig = (db) => async (params) => {
       drizzleOrm.and(
         drizzleOrm.eq(contextConfigs.tenantId, params.scopes.tenantId),
         drizzleOrm.eq(contextConfigs.projectId, params.scopes.projectId),
-        drizzleOrm.eq(contextConfigs.graphId, params.scopes.graphId),
+        drizzleOrm.eq(contextConfigs.agentId, params.scopes.agentId),
         drizzleOrm.eq(contextConfigs.id, params.id)
       )
     ).returning();
@@ -215872,7 +215836,7 @@ var countContextConfigs = (db) => async (params) => {
     drizzleOrm.and(
       drizzleOrm.eq(contextConfigs.tenantId, params.scopes.tenantId),
       drizzleOrm.eq(contextConfigs.projectId, params.scopes.projectId),
-      drizzleOrm.eq(contextConfigs.graphId, params.scopes.graphId)
+      drizzleOrm.eq(contextConfigs.agentId, params.scopes.agentId)
     )
   );
   const total = result[0]?.count || 0;
@@ -215882,7 +215846,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)({
@@ -215911,7 +215875,7 @@ var getExternalAgent = (db) => async (params) => {
     where: drizzleOrm.and(
       drizzleOrm.eq(externalAgents.tenantId, params.scopes.tenantId),
       drizzleOrm.eq(externalAgents.projectId, params.scopes.projectId),
-      drizzleOrm.eq(externalAgents.graphId, params.scopes.graphId),
+      drizzleOrm.eq(externalAgents.agentId, params.scopes.agentId),
       drizzleOrm.eq(externalAgents.id, params.subAgentId)
     )
   });
@@ -215922,7 +215886,7 @@ var getExternalAgentByUrl = (db) => async (params) => {
     where: drizzleOrm.and(
       drizzleOrm.eq(externalAgents.tenantId, params.scopes.tenantId),
       drizzleOrm.eq(externalAgents.projectId, params.scopes.projectId),
-      drizzleOrm.eq(externalAgents.graphId, params.scopes.graphId),
+      drizzleOrm.eq(externalAgents.agentId, params.scopes.agentId),
       drizzleOrm.eq(externalAgents.baseUrl, params.baseUrl)
     )
   });
@@ -215933,7 +215897,7 @@ var listExternalAgents = (db) => async (params) => {
     where: drizzleOrm.and(
       drizzleOrm.eq(externalAgents.tenantId, params.scopes.tenantId),
       drizzleOrm.eq(externalAgents.projectId, params.scopes.projectId),
-      drizzleOrm.eq(externalAgents.graphId, params.scopes.graphId)
+      drizzleOrm.eq(externalAgents.agentId, params.scopes.agentId)
     ),
     orderBy: [drizzleOrm.asc(externalAgents.name)]
   });
@@ -215947,14 +215911,14 @@ var listExternalAgentsPaginated = (db) => async (params) => {
       drizzleOrm.and(
         drizzleOrm.eq(externalAgents.tenantId, params.scopes.tenantId),
         drizzleOrm.eq(externalAgents.projectId, params.scopes.projectId),
-        drizzleOrm.eq(externalAgents.graphId, params.scopes.graphId)
+        drizzleOrm.eq(externalAgents.agentId, params.scopes.agentId)
       )
     ).limit(limit).offset(offset).orderBy(drizzleOrm.desc(externalAgents.createdAt)),
     db.select({ count: drizzleOrm.count() }).from(externalAgents).where(
       drizzleOrm.and(
         drizzleOrm.eq(externalAgents.tenantId, params.scopes.tenantId),
         drizzleOrm.eq(externalAgents.projectId, params.scopes.projectId),
-        drizzleOrm.eq(externalAgents.graphId, params.scopes.graphId)
+        drizzleOrm.eq(externalAgents.agentId, params.scopes.agentId)
       )
     )
   ]);
@@ -215983,7 +215947,7 @@ var updateExternalAgent = (db) => async (params) => {
     drizzleOrm.and(
       drizzleOrm.eq(externalAgents.tenantId, params.scopes.tenantId),
       drizzleOrm.eq(externalAgents.projectId, params.scopes.projectId),
-      drizzleOrm.eq(externalAgents.graphId, params.scopes.graphId),
+      drizzleOrm.eq(externalAgents.agentId, params.scopes.agentId),
       drizzleOrm.eq(externalAgents.id, params.subAgentId)
     )
   ).returning();
@@ -215993,7 +215957,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,
@@ -216025,7 +215989,7 @@ var deleteExternalAgent = (db) => async (params) => {
       drizzleOrm.and(
         drizzleOrm.eq(externalAgents.tenantId, params.scopes.tenantId),
         drizzleOrm.eq(externalAgents.projectId, params.scopes.projectId),
-        drizzleOrm.eq(externalAgents.graphId, params.scopes.graphId),
+        drizzleOrm.eq(externalAgents.agentId, params.scopes.agentId),
         drizzleOrm.eq(externalAgents.id, params.subAgentId)
       )
     ).returning();
@@ -216048,7 +216012,7 @@ var countExternalAgents = (db) => async (params) => {
     drizzleOrm.and(
       drizzleOrm.eq(externalAgents.tenantId, params.scopes.tenantId),
       drizzleOrm.eq(externalAgents.projectId, params.scopes.projectId),
-      drizzleOrm.eq(externalAgents.graphId, params.scopes.graphId)
+      drizzleOrm.eq(externalAgents.agentId, params.scopes.agentId)
     )
   );
   const countValue = result[0]?.count;
@@ -216192,7 +216156,7 @@ var getFunctionToolById = (db) => async (params) => {
     drizzleOrm.and(
       drizzleOrm.eq(functionTools.tenantId, params.scopes.tenantId),
       drizzleOrm.eq(functionTools.projectId, params.scopes.projectId),
-      drizzleOrm.eq(functionTools.graphId, params.scopes.graphId),
+      drizzleOrm.eq(functionTools.agentId, params.scopes.agentId),
       drizzleOrm.eq(functionTools.id, params.functionToolId)
     )
   ).limit(1);
@@ -216205,7 +216169,7 @@ var listFunctionTools = (db) => async (params) => {
   const whereClause = drizzleOrm.and(
     drizzleOrm.eq(functionTools.tenantId, params.scopes.tenantId),
     drizzleOrm.eq(functionTools.projectId, params.scopes.projectId),
-    drizzleOrm.eq(functionTools.graphId, params.scopes.graphId)
+    drizzleOrm.eq(functionTools.agentId, params.scopes.agentId)
   );
   const [functionToolsDbResults, totalResult] = await Promise.all([
     db.select().from(functionTools).where(whereClause).limit(limit).offset(offset).orderBy(drizzleOrm.desc(functionTools.createdAt)),
@@ -216220,11 +216184,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,
@@ -216243,7 +216207,7 @@ var updateFunctionTool = (db) => async (params) => {
     drizzleOrm.and(
       drizzleOrm.eq(functionTools.tenantId, params.scopes.tenantId),
       drizzleOrm.eq(functionTools.projectId, params.scopes.projectId),
-      drizzleOrm.eq(functionTools.graphId, params.scopes.graphId),
+      drizzleOrm.eq(functionTools.agentId, params.scopes.agentId),
       drizzleOrm.eq(functionTools.id, params.functionToolId)
     )
   ).returning();
@@ -216254,7 +216218,7 @@ var deleteFunctionTool = (db) => async (params) => {
     drizzleOrm.and(
       drizzleOrm.eq(functionTools.tenantId, params.scopes.tenantId),
       drizzleOrm.eq(functionTools.projectId, params.scopes.projectId),
-      drizzleOrm.eq(functionTools.graphId, params.scopes.graphId),
+      drizzleOrm.eq(functionTools.agentId, params.scopes.agentId),
       drizzleOrm.eq(functionTools.id, params.functionToolId)
     )
   ).returning();
@@ -216264,7 +216228,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,
@@ -216290,17 +216254,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 relations2 = await db.select().from(agentFunctionToolRelations).where(
         drizzleOrm.and(
           drizzleOrm.eq(agentFunctionToolRelations.tenantId, tenantId),
           drizzleOrm.eq(agentFunctionToolRelations.projectId, projectId),
-          drizzleOrm.eq(agentFunctionToolRelations.graphId, graphId),
+          drizzleOrm.eq(agentFunctionToolRelations.agentId, agentId),
           drizzleOrm.eq(agentFunctionToolRelations.subAgentId, subAgentId)
         )
       );
@@ -216314,7 +216278,7 @@ var getFunctionToolsForSubAgent = (db) => {
       };
     } catch (error) {
       logger4.error(
-        { tenantId, projectId, graphId, subAgentId, error },
+        { tenantId, projectId, agentId, subAgentId, error },
         "Failed to get function tools for agent"
       );
       throw error;
@@ -216337,25 +216301,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.nanoid();
       await db.insert(agentFunctionToolRelations).values({
         id: relationId,
         tenantId,
         projectId,
-        graphId,
+        agentId,
         subAgentId,
         functionToolId
       });
       logger4.info(
-        { tenantId, projectId, graphId, subAgentId, functionToolId, relationId },
+        { tenantId, projectId, agentId, subAgentId, functionToolId, relationId },
         "Function tool added to agent"
       );
       return { id: relationId };
     } catch (error) {
       logger4.error(
-        { tenantId, projectId, graphId, subAgentId, functionToolId, error },
+        { tenantId, projectId, agentId, subAgentId, functionToolId, error },
         "Failed to add function tool to agent"
       );
       throw error;
@@ -216365,7 +216329,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,
@@ -216375,17 +216339,17 @@ var updateSubAgentFunctionToolRelation = (db) => {
           drizzleOrm.eq(agentFunctionToolRelations.id, relationId),
           drizzleOrm.eq(agentFunctionToolRelations.tenantId, tenantId),
           drizzleOrm.eq(agentFunctionToolRelations.projectId, projectId),
-          drizzleOrm.eq(agentFunctionToolRelations.graphId, graphId)
+          drizzleOrm.eq(agentFunctionToolRelations.agentId, agentId)
         )
       );
       logger4.info(
-        { tenantId, projectId, graphId, relationId, data },
+        { tenantId, projectId, agentId, relationId, data },
         "Agent-function tool relation updated"
       );
       return { id: relationId };
     } catch (error) {
       logger4.error(
-        { tenantId, projectId, graphId, relationId, data, error },
+        { tenantId, projectId, agentId, relationId, data, error },
         "Failed to update agent-function tool relation"
       );
       throw error;
@@ -216397,7 +216361,7 @@ var getAgentRelationById = (db) => async (params) => {
     where: drizzleOrm.and(
       drizzleOrm.eq(subAgentRelations.tenantId, params.scopes.tenantId),
       drizzleOrm.eq(subAgentRelations.projectId, params.scopes.projectId),
-      drizzleOrm.eq(subAgentRelations.graphId, params.scopes.graphId),
+      drizzleOrm.eq(subAgentRelations.agentId, params.scopes.agentId),
       drizzleOrm.eq(subAgentRelations.id, params.relationId)
     )
   });
@@ -216409,7 +216373,7 @@ var listAgentRelations = (db) => async (params) => {
   const whereClause = drizzleOrm.and(
     drizzleOrm.eq(subAgentRelations.tenantId, params.scopes.tenantId),
     drizzleOrm.eq(subAgentRelations.projectId, params.scopes.projectId),
-    drizzleOrm.eq(subAgentRelations.graphId, params.scopes.graphId)
+    drizzleOrm.eq(subAgentRelations.agentId, params.scopes.agentId)
   );
   const [data, totalResult] = await Promise.all([
     db.select().from(subAgentRelations).where(whereClause).limit(limit).offset(offset).orderBy(drizzleOrm.desc(subAgentRelations.createdAt)),
@@ -216424,17 +216388,17 @@ var getAgentRelations = (db) => async (params) => {
     where: drizzleOrm.and(
       drizzleOrm.eq(subAgentRelations.tenantId, params.scopes.tenantId),
       drizzleOrm.eq(subAgentRelations.projectId, params.scopes.projectId),
-      drizzleOrm.eq(subAgentRelations.graphId, params.scopes.graphId),
+      drizzleOrm.eq(subAgentRelations.agentId, params.scopes.agentId),
       drizzleOrm.eq(subAgentRelations.sourceSubAgentId, params.scopes.subAgentId)
     )
   });
 };
-var getAgentRelationsByGraph = (db) => async (params) => {
+var getAgentRelationsByAgent = (db) => async (params) => {
   return await db.query.subAgentRelations.findMany({
     where: drizzleOrm.and(
       drizzleOrm.eq(subAgentRelations.tenantId, params.scopes.tenantId),
       drizzleOrm.eq(subAgentRelations.projectId, params.scopes.projectId),
-      drizzleOrm.eq(subAgentRelations.graphId, params.scopes.graphId)
+      drizzleOrm.eq(subAgentRelations.agentId, params.scopes.agentId)
     )
   });
 };
@@ -216445,7 +216409,7 @@ var getAgentRelationsBySource = (db) => async (params) => {
   const whereClause = drizzleOrm.and(
     drizzleOrm.eq(subAgentRelations.tenantId, params.scopes.tenantId),
     drizzleOrm.eq(subAgentRelations.projectId, params.scopes.projectId),
-    drizzleOrm.eq(subAgentRelations.graphId, params.scopes.graphId),
+    drizzleOrm.eq(subAgentRelations.agentId, params.scopes.agentId),
     drizzleOrm.eq(subAgentRelations.sourceSubAgentId, params.sourceSubAgentId)
   );
   const [data, totalResult] = await Promise.all([
@@ -216466,7 +216430,7 @@ var getAgentRelationsByTarget = (db) => async (params) => {
   const whereClause = drizzleOrm.and(
     drizzleOrm.eq(subAgentRelations.tenantId, params.scopes.tenantId),
     drizzleOrm.eq(subAgentRelations.projectId, params.scopes.projectId),
-    drizzleOrm.eq(subAgentRelations.graphId, params.scopes.graphId),
+    drizzleOrm.eq(subAgentRelations.agentId, params.scopes.agentId),
     drizzleOrm.eq(subAgentRelations.targetSubAgentId, params.targetSubAgentId)
   );
   const [data, totalResult] = await Promise.all([
@@ -216487,7 +216451,7 @@ var getExternalAgentRelations = (db) => async (params) => {
   const whereClause = drizzleOrm.and(
     drizzleOrm.eq(subAgentRelations.tenantId, params.scopes.tenantId),
     drizzleOrm.eq(subAgentRelations.projectId, params.scopes.projectId),
-    drizzleOrm.eq(subAgentRelations.graphId, params.scopes.graphId),
+    drizzleOrm.eq(subAgentRelations.agentId, params.scopes.agentId),
     drizzleOrm.eq(subAgentRelations.externalSubAgentId, params.externalSubAgentId)
   );
   const [data, totalResult] = await Promise.all([
@@ -216501,7 +216465,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,
@@ -216513,13 +216477,13 @@ var getRelatedAgentsForGraph = (db) => async (params) => {
       drizzleOrm.eq(subAgentRelations.targetSubAgentId, subAgents.id),
       drizzleOrm.eq(subAgentRelations.tenantId, subAgents.tenantId),
       drizzleOrm.eq(subAgentRelations.projectId, subAgents.projectId),
-      drizzleOrm.eq(subAgentRelations.graphId, subAgents.graphId)
+      drizzleOrm.eq(subAgentRelations.agentId, subAgents.agentId)
     )
   ).where(
     drizzleOrm.and(
       drizzleOrm.eq(subAgentRelations.tenantId, params.scopes.tenantId),
       drizzleOrm.eq(subAgentRelations.projectId, params.scopes.projectId),
-      drizzleOrm.eq(subAgentRelations.graphId, params.scopes.graphId),
+      drizzleOrm.eq(subAgentRelations.agentId, params.scopes.agentId),
       drizzleOrm.eq(subAgentRelations.sourceSubAgentId, params.subAgentId),
       drizzleOrm.isNotNull(subAgentRelations.targetSubAgentId)
     )
@@ -216539,13 +216503,13 @@ var getRelatedAgentsForGraph = (db) => async (params) => {
       drizzleOrm.eq(subAgentRelations.externalSubAgentId, externalAgents.id),
       drizzleOrm.eq(subAgentRelations.tenantId, externalAgents.tenantId),
       drizzleOrm.eq(subAgentRelations.projectId, externalAgents.projectId),
-      drizzleOrm.eq(subAgentRelations.graphId, externalAgents.graphId)
+      drizzleOrm.eq(subAgentRelations.agentId, externalAgents.agentId)
     )
   ).where(
     drizzleOrm.and(
       drizzleOrm.eq(subAgentRelations.tenantId, params.scopes.tenantId),
       drizzleOrm.eq(subAgentRelations.projectId, params.scopes.projectId),
-      drizzleOrm.eq(subAgentRelations.graphId, params.scopes.graphId),
+      drizzleOrm.eq(subAgentRelations.agentId, params.scopes.agentId),
       drizzleOrm.eq(subAgentRelations.sourceSubAgentId, params.subAgentId),
       drizzleOrm.isNotNull(subAgentRelations.externalSubAgentId)
     )
@@ -216573,7 +216537,7 @@ var getAgentRelationByParams = (db) => async (params) => {
   const whereConditions = [
     drizzleOrm.eq(subAgentRelations.tenantId, params.scopes.tenantId),
     drizzleOrm.eq(subAgentRelations.projectId, params.scopes.projectId),
-    drizzleOrm.eq(subAgentRelations.graphId, params.scopes.graphId),
+    drizzleOrm.eq(subAgentRelations.agentId, params.scopes.agentId),
     drizzleOrm.eq(subAgentRelations.sourceSubAgentId, params.sourceSubAgentId),
     drizzleOrm.eq(subAgentRelations.relationType, params.relationType)
   ];
@@ -216589,7 +216553,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,
@@ -216615,7 +216579,7 @@ var updateAgentRelation = (db) => async (params) => {
     drizzleOrm.and(
       drizzleOrm.eq(subAgentRelations.tenantId, params.scopes.tenantId),
       drizzleOrm.eq(subAgentRelations.projectId, params.scopes.projectId),
-      drizzleOrm.eq(subAgentRelations.graphId, params.scopes.graphId),
+      drizzleOrm.eq(subAgentRelations.agentId, params.scopes.agentId),
       drizzleOrm.eq(subAgentRelations.id, params.relationId)
     )
   ).returning();
@@ -216626,17 +216590,17 @@ var deleteSubAgentRelation = (db) => async (params) => {
     drizzleOrm.and(
       drizzleOrm.eq(subAgentRelations.tenantId, params.scopes.tenantId),
       drizzleOrm.eq(subAgentRelations.projectId, params.scopes.projectId),
-      drizzleOrm.eq(subAgentRelations.graphId, params.scopes.graphId),
+      drizzleOrm.eq(subAgentRelations.agentId, params.scopes.agentId),
       drizzleOrm.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(
     drizzleOrm.and(
       drizzleOrm.eq(subAgentRelations.tenantId, params.scopes.tenantId),
-      drizzleOrm.eq(subAgentRelations.graphId, params.scopes.graphId)
+      drizzleOrm.eq(subAgentRelations.agentId, params.scopes.agentId)
     )
   );
   return (result.rowsAffected || 0) > 0;
@@ -216647,7 +216611,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,
@@ -216664,7 +216628,7 @@ var updateAgentToolRelation = (db) => async (params) => {
     drizzleOrm.and(
       drizzleOrm.eq(subAgentToolRelations.tenantId, params.scopes.tenantId),
       drizzleOrm.eq(subAgentToolRelations.projectId, params.scopes.projectId),
-      drizzleOrm.eq(subAgentToolRelations.graphId, params.scopes.graphId),
+      drizzleOrm.eq(subAgentToolRelations.agentId, params.scopes.agentId),
       drizzleOrm.eq(subAgentToolRelations.id, params.relationId)
     )
   ).returning();
@@ -216675,7 +216639,7 @@ var deleteAgentToolRelation = (db) => async (params) => {
     drizzleOrm.and(
       drizzleOrm.eq(subAgentToolRelations.tenantId, params.scopes.tenantId),
       drizzleOrm.eq(subAgentToolRelations.projectId, params.scopes.projectId),
-      drizzleOrm.eq(subAgentToolRelations.graphId, params.scopes.graphId),
+      drizzleOrm.eq(subAgentToolRelations.agentId, params.scopes.agentId),
       drizzleOrm.eq(subAgentToolRelations.id, params.relationId)
     )
   );
@@ -216686,7 +216650,7 @@ var deleteAgentToolRelationByAgent = (db) => async (params) => {
     drizzleOrm.and(
       drizzleOrm.eq(subAgentToolRelations.tenantId, params.scopes.tenantId),
       drizzleOrm.eq(subAgentToolRelations.projectId, params.scopes.projectId),
-      drizzleOrm.eq(subAgentToolRelations.graphId, params.scopes.graphId),
+      drizzleOrm.eq(subAgentToolRelations.agentId, params.scopes.agentId),
       drizzleOrm.eq(subAgentToolRelations.subAgentId, params.scopes.subAgentId)
     )
   );
@@ -216697,7 +216661,7 @@ var getAgentToolRelationById = (db) => async (params) => {
     where: drizzleOrm.and(
       drizzleOrm.eq(subAgentToolRelations.tenantId, params.scopes.tenantId),
       drizzleOrm.eq(subAgentToolRelations.projectId, params.scopes.projectId),
-      drizzleOrm.eq(subAgentToolRelations.graphId, params.scopes.graphId),
+      drizzleOrm.eq(subAgentToolRelations.agentId, params.scopes.agentId),
       drizzleOrm.eq(subAgentToolRelations.id, params.relationId)
     )
   });
@@ -216738,7 +216702,7 @@ var getAgentToolRelationByTool = (db) => async (params) => {
       drizzleOrm.and(
         drizzleOrm.eq(subAgentToolRelations.tenantId, params.scopes.tenantId),
         drizzleOrm.eq(subAgentToolRelations.projectId, params.scopes.projectId),
-        drizzleOrm.eq(subAgentToolRelations.graphId, params.scopes.graphId),
+        drizzleOrm.eq(subAgentToolRelations.agentId, params.scopes.agentId),
         drizzleOrm.eq(subAgentToolRelations.toolId, params.toolId)
       )
     ).limit(limit).offset(offset).orderBy(drizzleOrm.desc(subAgentToolRelations.createdAt)),
@@ -216746,7 +216710,7 @@ var getAgentToolRelationByTool = (db) => async (params) => {
       drizzleOrm.and(
         drizzleOrm.eq(subAgentToolRelations.tenantId, params.scopes.tenantId),
         drizzleOrm.eq(subAgentToolRelations.projectId, params.scopes.projectId),
-        drizzleOrm.eq(subAgentToolRelations.graphId, params.scopes.graphId),
+        drizzleOrm.eq(subAgentToolRelations.agentId, params.scopes.agentId),
         drizzleOrm.eq(subAgentToolRelations.toolId, params.toolId)
       )
     )
@@ -216767,14 +216731,14 @@ var listAgentToolRelations = (db) => async (params) => {
       drizzleOrm.and(
         drizzleOrm.eq(subAgentToolRelations.tenantId, params.scopes.tenantId),
         drizzleOrm.eq(subAgentToolRelations.projectId, params.scopes.projectId),
-        drizzleOrm.eq(subAgentToolRelations.graphId, params.scopes.graphId)
+        drizzleOrm.eq(subAgentToolRelations.agentId, params.scopes.agentId)
       )
     ).limit(limit).offset(offset).orderBy(drizzleOrm.desc(subAgentToolRelations.createdAt)),
     db.select({ count: drizzleOrm.count() }).from(subAgentToolRelations).where(
       drizzleOrm.and(
         drizzleOrm.eq(subAgentToolRelations.tenantId, params.scopes.tenantId),
         drizzleOrm.eq(subAgentToolRelations.projectId, params.scopes.projectId),
-        drizzleOrm.eq(subAgentToolRelations.graphId, params.scopes.graphId)
+        drizzleOrm.eq(subAgentToolRelations.agentId, params.scopes.agentId)
       )
     )
   ]);
@@ -216825,7 +216789,7 @@ var getToolsForAgent = (db) => async (params) => {
       drizzleOrm.and(
         drizzleOrm.eq(subAgentToolRelations.tenantId, params.scopes.tenantId),
         drizzleOrm.eq(subAgentToolRelations.projectId, params.scopes.projectId),
-        drizzleOrm.eq(subAgentToolRelations.graphId, params.scopes.graphId),
+        drizzleOrm.eq(subAgentToolRelations.agentId, params.scopes.agentId),
         drizzleOrm.eq(subAgentToolRelations.subAgentId, params.scopes.subAgentId)
       )
     ).limit(limit).offset(offset).orderBy(drizzleOrm.desc(subAgentToolRelations.createdAt)),
@@ -216833,7 +216797,7 @@ var getToolsForAgent = (db) => async (params) => {
       drizzleOrm.and(
         drizzleOrm.eq(subAgentToolRelations.tenantId, params.scopes.tenantId),
         drizzleOrm.eq(subAgentToolRelations.projectId, params.scopes.projectId),
-        drizzleOrm.eq(subAgentToolRelations.graphId, params.scopes.graphId),
+        drizzleOrm.eq(subAgentToolRelations.agentId, params.scopes.agentId),
         drizzleOrm.eq(subAgentToolRelations.subAgentId, params.scopes.subAgentId)
       )
     )
@@ -216876,13 +216840,13 @@ var getAgentsForTool = (db) => async (params) => {
         drizzleOrm.eq(subAgentToolRelations.subAgentId, subAgents.id),
         drizzleOrm.eq(subAgentToolRelations.tenantId, subAgents.tenantId),
         drizzleOrm.eq(subAgentToolRelations.projectId, subAgents.projectId),
-        drizzleOrm.eq(subAgentToolRelations.graphId, subAgents.graphId)
+        drizzleOrm.eq(subAgentToolRelations.agentId, subAgents.agentId)
       )
     ).where(
       drizzleOrm.and(
         drizzleOrm.eq(subAgentToolRelations.tenantId, params.scopes.tenantId),
         drizzleOrm.eq(subAgentToolRelations.projectId, params.scopes.projectId),
-        drizzleOrm.eq(subAgentToolRelations.graphId, params.scopes.graphId),
+        drizzleOrm.eq(subAgentToolRelations.agentId, params.scopes.agentId),
         drizzleOrm.eq(subAgentToolRelations.toolId, params.toolId)
       )
     ).limit(limit).offset(offset).orderBy(drizzleOrm.desc(subAgentToolRelations.createdAt)),
@@ -216890,7 +216854,7 @@ var getAgentsForTool = (db) => async (params) => {
       drizzleOrm.and(
         drizzleOrm.eq(subAgentToolRelations.tenantId, params.scopes.tenantId),
         drizzleOrm.eq(subAgentToolRelations.projectId, params.scopes.projectId),
-        drizzleOrm.eq(subAgentToolRelations.graphId, params.scopes.graphId),
+        drizzleOrm.eq(subAgentToolRelations.agentId, params.scopes.agentId),
         drizzleOrm.eq(subAgentToolRelations.toolId, params.toolId)
       )
     )
@@ -216907,7 +216871,7 @@ var validateInternalSubAgent = (db) => async (params) => {
     drizzleOrm.and(
       drizzleOrm.eq(subAgents.tenantId, params.scopes.tenantId),
       drizzleOrm.eq(subAgents.projectId, params.scopes.projectId),
-      drizzleOrm.eq(subAgents.graphId, params.scopes.graphId),
+      drizzleOrm.eq(subAgents.agentId, params.scopes.agentId),
       drizzleOrm.eq(subAgents.id, params.scopes.subAgentId)
     )
   ).limit(1);
@@ -216918,7 +216882,7 @@ var validateExternalAgent = (db) => async (params) => {
     drizzleOrm.and(
       drizzleOrm.eq(externalAgents.tenantId, params.scopes.tenantId),
       drizzleOrm.eq(externalAgents.projectId, params.scopes.projectId),
-      drizzleOrm.eq(externalAgents.graphId, params.scopes.graphId),
+      drizzleOrm.eq(externalAgents.agentId, params.scopes.agentId),
       drizzleOrm.eq(externalAgents.id, params.scopes.subAgentId)
     )
   ).limit(1);
@@ -216929,7 +216893,7 @@ var getSubAgentById = (db) => async (params) => {
     where: drizzleOrm.and(
       drizzleOrm.eq(subAgents.tenantId, params.scopes.tenantId),
       drizzleOrm.eq(subAgents.projectId, params.scopes.projectId),
-      drizzleOrm.eq(subAgents.graphId, params.scopes.graphId),
+      drizzleOrm.eq(subAgents.agentId, params.scopes.agentId),
       drizzleOrm.eq(subAgents.id, params.subAgentId)
     )
   });
@@ -216940,7 +216904,7 @@ var listSubAgents = (db) => async (params) => {
     where: drizzleOrm.and(
       drizzleOrm.eq(subAgents.tenantId, params.scopes.tenantId),
       drizzleOrm.eq(subAgents.projectId, params.scopes.projectId),
-      drizzleOrm.eq(subAgents.graphId, params.scopes.graphId)
+      drizzleOrm.eq(subAgents.agentId, params.scopes.agentId)
     )
   });
 };
@@ -216951,7 +216915,7 @@ var listSubAgentsPaginated = (db) => async (params) => {
   const whereClause = drizzleOrm.and(
     drizzleOrm.eq(subAgents.tenantId, params.scopes.tenantId),
     drizzleOrm.eq(subAgents.projectId, params.scopes.projectId),
-    drizzleOrm.eq(subAgents.graphId, params.scopes.graphId)
+    drizzleOrm.eq(subAgents.agentId, params.scopes.agentId)
   );
   const [data, totalResult] = await Promise.all([
     db.select().from(subAgents).where(whereClause).limit(limit).offset(offset).orderBy(drizzleOrm.desc(subAgents.createdAt)),
@@ -216983,7 +216947,7 @@ var updateSubAgent = (db) => async (params) => {
     drizzleOrm.and(
       drizzleOrm.eq(subAgents.tenantId, params.scopes.tenantId),
       drizzleOrm.eq(subAgents.projectId, params.scopes.projectId),
-      drizzleOrm.eq(subAgents.graphId, params.scopes.graphId),
+      drizzleOrm.eq(subAgents.agentId, params.scopes.agentId),
       drizzleOrm.eq(subAgents.id, params.subAgentId)
     )
   ).returning();
@@ -216993,7 +216957,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,
@@ -217025,7 +216989,7 @@ var deleteSubAgent = (db) => async (params) => {
     drizzleOrm.and(
       drizzleOrm.eq(subAgents.tenantId, params.scopes.tenantId),
       drizzleOrm.eq(subAgents.projectId, params.scopes.projectId),
-      drizzleOrm.eq(subAgents.graphId, params.scopes.graphId),
+      drizzleOrm.eq(subAgents.agentId, params.scopes.agentId),
       drizzleOrm.eq(subAgents.id, params.subAgentId)
     )
   );
@@ -217043,7 +217007,7 @@ var getSubAgentsByIds = (db) => async (params) => {
     drizzleOrm.and(
       drizzleOrm.eq(subAgents.tenantId, params.scopes.tenantId),
       drizzleOrm.eq(subAgents.projectId, params.scopes.projectId),
-      drizzleOrm.eq(subAgents.graphId, params.scopes.graphId),
+      drizzleOrm.eq(subAgents.agentId, params.scopes.agentId),
       drizzleOrm.inArray(subAgents.id, params.subAgentIds)
     )
   );
@@ -217511,7 +217475,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
   };
@@ -218131,7 +218095,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,
@@ -218146,7 +218110,7 @@ var removeToolFromAgent = (db) => async (params) => {
     drizzleOrm.and(
       drizzleOrm.eq(subAgentToolRelations.tenantId, params.scopes.tenantId),
       drizzleOrm.eq(subAgentToolRelations.projectId, params.scopes.projectId),
-      drizzleOrm.eq(subAgentToolRelations.graphId, params.scopes.graphId),
+      drizzleOrm.eq(subAgentToolRelations.agentId, params.scopes.agentId),
       drizzleOrm.eq(subAgentToolRelations.subAgentId, params.subAgentId),
       drizzleOrm.eq(subAgentToolRelations.toolId, params.toolId)
     )
@@ -218191,23 +218155,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: drizzleOrm.and(
-      drizzleOrm.eq(agentGraph.tenantId, params.scopes.tenantId),
-      drizzleOrm.eq(agentGraph.projectId, params.scopes.projectId),
-      drizzleOrm.eq(agentGraph.id, params.scopes.graphId)
+      drizzleOrm.eq(agents.tenantId, params.scopes.tenantId),
+      drizzleOrm.eq(agents.projectId, params.scopes.projectId),
+      drizzleOrm.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: drizzleOrm.and(
-      drizzleOrm.eq(agentGraph.tenantId, params.scopes.tenantId),
-      drizzleOrm.eq(agentGraph.projectId, params.scopes.projectId),
-      drizzleOrm.eq(agentGraph.id, params.scopes.graphId)
+      drizzleOrm.eq(agents.tenantId, params.scopes.tenantId),
+      drizzleOrm.eq(agents.projectId, params.scopes.projectId),
+      drizzleOrm.eq(agents.id, params.scopes.agentId)
     ),
     with: {
       defaultSubAgent: true
@@ -218215,26 +218179,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: drizzleOrm.and(
-      drizzleOrm.eq(agentGraph.tenantId, params.scopes.tenantId),
-      drizzleOrm.eq(agentGraph.projectId, params.scopes.projectId)
+      drizzleOrm.eq(agents.tenantId, params.scopes.tenantId),
+      drizzleOrm.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 = drizzleOrm.and(
-    drizzleOrm.eq(agentGraph.tenantId, params.scopes.tenantId),
-    drizzleOrm.eq(agentGraph.projectId, params.scopes.projectId)
+    drizzleOrm.eq(agents.tenantId, params.scopes.tenantId),
+    drizzleOrm.eq(agents.projectId, params.scopes.projectId)
   );
-  const query = db.select().from(agentGraph).where(whereClause).limit(limit).offset(offset).orderBy(drizzleOrm.desc(agentGraph.createdAt));
+  const query = db.select().from(agents).where(whereClause).limit(limit).offset(offset).orderBy(drizzleOrm.desc(agents.createdAt));
   const [data, totalResult] = await Promise.all([
     query,
-    db.select({ count: drizzleOrm.count() }).from(agentGraph).where(whereClause)
+    db.select({ count: drizzleOrm.count() }).from(agents).where(whereClause)
   ]);
   const total = totalResult[0]?.count || 0;
   const pages = Math.ceil(total / limit);
@@ -218243,74 +218207,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(
     drizzleOrm.and(
-      drizzleOrm.eq(agentGraph.tenantId, params.scopes.tenantId),
-      drizzleOrm.eq(agentGraph.projectId, params.scopes.projectId),
-      drizzleOrm.eq(agentGraph.id, params.scopes.graphId)
+      drizzleOrm.eq(agents.tenantId, params.scopes.tenantId),
+      drizzleOrm.eq(agents.projectId, params.scopes.projectId),
+      drizzleOrm.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(
     drizzleOrm.and(
-      drizzleOrm.eq(agentGraph.tenantId, params.scopes.tenantId),
-      drizzleOrm.eq(agentGraph.projectId, params.scopes.projectId),
-      drizzleOrm.eq(agentGraph.id, params.scopes.graphId)
+      drizzleOrm.eq(agents.tenantId, params.scopes.tenantId),
+      drizzleOrm.eq(agents.projectId, params.scopes.projectId),
+      drizzleOrm.eq(agents.id, params.scopes.agentId)
     )
   ).returning();
   return result.length > 0;
@@ -218318,7 +218270,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, drizzleOrm.eq(config.relationIdField, config.componentIdField)).where(
+    const results = await db.select(config.selectFields).from(config.relationTable).innerJoin(
+      config.componentTable,
+      drizzleOrm.eq(config.relationIdField, config.componentIdField)
+    ).where(
       drizzleOrm.and(
         drizzleOrm.eq(config.relationTable.tenantId, scopes.tenantId),
         drizzleOrm.eq(config.relationTable.projectId, scopes.projectId),
@@ -218331,20 +218286,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 relations2 = await getAgentRelations(db)({
-    scopes: { tenantId, projectId, graphId, subAgentId }
+    scopes: { tenantId, projectId, agentId, subAgentId }
   });
   const targetSubAgentIds = relations2.map((relation) => relation.targetSubAgentId).filter((id) => id !== null);
   if (targetSubAgentIds.length === 0) {
@@ -218352,48 +218306,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: drizzleOrm.and(
       drizzleOrm.eq(subAgents.tenantId, tenantId),
       drizzleOrm.eq(subAgents.projectId, projectId),
-      drizzleOrm.eq(subAgents.graphId, graphId)
+      drizzleOrm.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);
@@ -218423,8 +218374,8 @@ var getFullGraphDefinition = (db) => async ({
         drizzleOrm.and(
           drizzleOrm.eq(subAgentToolRelations.tenantId, tenantId),
           drizzleOrm.eq(subAgentToolRelations.projectId, projectId),
-          drizzleOrm.eq(subAgentToolRelations.graphId, graphId),
-          drizzleOrm.eq(subAgentToolRelations.subAgentId, agent.id)
+          drizzleOrm.eq(subAgentToolRelations.agentId, agentId),
+          drizzleOrm.eq(subAgentToolRelations.subAgentId, agent2.id)
         )
       );
       const agentFunctionTools = await db.select({
@@ -218436,7 +218387,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,
@@ -218444,27 +218395,27 @@ var getFullGraphDefinition = (db) => async ({
           drizzleOrm.eq(agentFunctionToolRelations.functionToolId, functionTools.id),
           drizzleOrm.eq(agentFunctionToolRelations.tenantId, functionTools.tenantId),
           drizzleOrm.eq(agentFunctionToolRelations.projectId, functionTools.projectId),
-          drizzleOrm.eq(agentFunctionToolRelations.graphId, functionTools.graphId)
+          drizzleOrm.eq(agentFunctionToolRelations.agentId, functionTools.agentId)
         )
       ).where(
         drizzleOrm.and(
           drizzleOrm.eq(agentFunctionToolRelations.tenantId, tenantId),
           drizzleOrm.eq(agentFunctionToolRelations.projectId, projectId),
-          drizzleOrm.eq(agentFunctionToolRelations.graphId, graphId),
-          drizzleOrm.eq(agentFunctionToolRelations.subAgentId, agent.id)
+          drizzleOrm.eq(agentFunctionToolRelations.agentId, agentId),
+          drizzleOrm.eq(agentFunctionToolRelations.subAgentId, agent2.id)
         )
       );
       const agentDataComponentRelations = await db.query.subAgentDataComponents.findMany({
         where: drizzleOrm.and(
           drizzleOrm.eq(subAgentDataComponents.tenantId, tenantId),
-          drizzleOrm.eq(subAgentDataComponents.subAgentId, agent.id)
+          drizzleOrm.eq(subAgentDataComponents.subAgentId, agent2.id)
         )
       });
       const agentDataComponentIds = agentDataComponentRelations.map((rel) => rel.dataComponentId);
       const agentArtifactComponentRelations = await db.query.subAgentArtifactComponents.findMany({
         where: drizzleOrm.and(
           drizzleOrm.eq(subAgentArtifactComponents.tenantId, tenantId),
-          drizzleOrm.eq(subAgentArtifactComponents.subAgentId, agent.id)
+          drizzleOrm.eq(subAgentArtifactComponents.subAgentId, agent2.id)
         )
       });
       const agentArtifactComponentIds = agentArtifactComponentRelations.map(
@@ -218486,12 +218437,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,
@@ -218503,54 +218454,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,
@@ -218569,7 +218514,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,
@@ -218588,33 +218533,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) {
@@ -218625,33 +218566,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(
-                  drizzleOrm.and(
-                    drizzleOrm.eq(subAgents.tenantId, tenantId),
-                    drizzleOrm.eq(subAgents.projectId, projectId),
-                    drizzleOrm.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(
+                    drizzleOrm.and(
+                      drizzleOrm.eq(subAgents.tenantId, tenantId),
+                      drizzleOrm.eq(subAgents.projectId, projectId),
+                      drizzleOrm.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);
+                }
               }
             }
           }
@@ -218679,7 +218623,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 = {};
@@ -218699,36 +218643,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.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.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,
@@ -218739,12 +218685,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({
@@ -218765,8 +218710,8 @@ var listApiKeys = (db) => async (params) => {
     drizzleOrm.eq(apiKeys.tenantId, params.scopes.tenantId),
     drizzleOrm.eq(apiKeys.projectId, params.scopes.projectId)
   ];
-  if (params.graphId) {
-    conditions.push(drizzleOrm.eq(apiKeys.graphId, params.graphId));
+  if (params.agentId) {
+    conditions.push(drizzleOrm.eq(apiKeys.agentId, params.agentId));
   }
   return await db.query.apiKeys.findMany({
     where: drizzleOrm.and(...conditions),
@@ -218781,8 +218726,8 @@ var listApiKeysPaginated = (db) => async (params) => {
     drizzleOrm.eq(apiKeys.tenantId, params.scopes.tenantId),
     drizzleOrm.eq(apiKeys.projectId, params.scopes.projectId)
   ];
-  if (params.graphId) {
-    conditions.push(drizzleOrm.eq(apiKeys.graphId, params.graphId));
+  if (params.agentId) {
+    conditions.push(drizzleOrm.eq(apiKeys.agentId, params.agentId));
   }
   const whereClause = drizzleOrm.and(...conditions);
   const [data, totalResult] = await Promise.all([
@@ -218804,7 +218749,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,
@@ -218863,20 +218808,20 @@ var countApiKeys = (db) => async (params) => {
     drizzleOrm.eq(apiKeys.tenantId, params.scopes.tenantId),
     drizzleOrm.eq(apiKeys.projectId, params.scopes.projectId)
   ];
-  if (params.graphId) {
-    conditions.push(drizzleOrm.eq(apiKeys.graphId, params.graphId));
+  if (params.agentId) {
+    conditions.push(drizzleOrm.eq(apiKeys.agentId, params.agentId));
   }
   const result = await db.select({ count: drizzleOrm.count() }).from(apiKeys).where(drizzleOrm.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
@@ -219120,7 +219065,7 @@ var getArtifactComponentsForAgent = (db) => async (params) => {
     drizzleOrm.and(
       drizzleOrm.eq(artifactComponents.tenantId, params.scopes.tenantId),
       drizzleOrm.eq(artifactComponents.projectId, params.scopes.projectId),
-      drizzleOrm.eq(subAgentArtifactComponents.graphId, params.scopes.graphId),
+      drizzleOrm.eq(subAgentArtifactComponents.agentId, params.scopes.agentId),
       drizzleOrm.eq(subAgentArtifactComponents.subAgentId, params.scopes.subAgentId)
     )
   ).orderBy(drizzleOrm.desc(artifactComponents.createdAt));
@@ -219130,7 +219075,7 @@ var associateArtifactComponentWithAgent = (db) => async (params) => {
     id: nanoid.nanoid(),
     tenantId: params.scopes.tenantId,
     projectId: params.scopes.projectId,
-    graphId: params.scopes.graphId,
+    agentId: params.scopes.agentId,
     subAgentId: params.scopes.subAgentId,
     artifactComponentId: params.artifactComponentId,
     createdAt: (/* @__PURE__ */ new Date()).toISOString()
@@ -219143,7 +219088,7 @@ var removeArtifactComponentFromAgent = (db) => async (params) => {
       drizzleOrm.and(
         drizzleOrm.eq(subAgentArtifactComponents.tenantId, params.scopes.tenantId),
         drizzleOrm.eq(subAgentArtifactComponents.projectId, params.scopes.projectId),
-        drizzleOrm.eq(subAgentArtifactComponents.graphId, params.scopes.graphId),
+        drizzleOrm.eq(subAgentArtifactComponents.agentId, params.scopes.agentId),
         drizzleOrm.eq(subAgentArtifactComponents.subAgentId, params.scopes.subAgentId),
         drizzleOrm.eq(subAgentArtifactComponents.artifactComponentId, params.artifactComponentId)
       )
@@ -219158,7 +219103,7 @@ var deleteAgentArtifactComponentRelationByAgent = (db) => async (params) => {
   const result = await db.delete(subAgentArtifactComponents).where(
     drizzleOrm.and(
       drizzleOrm.eq(subAgentArtifactComponents.tenantId, params.scopes.tenantId),
-      drizzleOrm.eq(subAgentArtifactComponents.graphId, params.scopes.graphId),
+      drizzleOrm.eq(subAgentArtifactComponents.agentId, params.scopes.agentId),
       drizzleOrm.eq(subAgentArtifactComponents.subAgentId, params.scopes.subAgentId)
     )
   );
@@ -219166,7 +219111,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(
@@ -219182,14 +219127,14 @@ var isArtifactComponentAssociatedWithAgent = (db) => async (params) => {
     drizzleOrm.and(
       drizzleOrm.eq(subAgentArtifactComponents.tenantId, params.scopes.tenantId),
       drizzleOrm.eq(subAgentArtifactComponents.projectId, params.scopes.projectId),
-      drizzleOrm.eq(subAgentArtifactComponents.graphId, params.scopes.graphId),
+      drizzleOrm.eq(subAgentArtifactComponents.agentId, params.scopes.agentId),
       drizzleOrm.eq(subAgentArtifactComponents.subAgentId, params.scopes.subAgentId),
       drizzleOrm.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: drizzleOrm.count() }).from(subAgentArtifactComponents).innerJoin(
     subAgents,
     drizzleOrm.and(
@@ -219202,13 +219147,13 @@ var graphHasArtifactComponents = (db) => async (params) => {
       drizzleOrm.eq(subAgents.id, subAgentRelations.sourceSubAgentId),
       drizzleOrm.eq(subAgents.tenantId, subAgentRelations.tenantId),
       drizzleOrm.eq(subAgents.projectId, subAgentRelations.projectId),
-      drizzleOrm.eq(subAgents.graphId, subAgentRelations.graphId)
+      drizzleOrm.eq(subAgents.agentId, subAgentRelations.agentId)
     )
   ).where(
     drizzleOrm.and(
       drizzleOrm.eq(subAgentArtifactComponents.tenantId, params.scopes.tenantId),
       drizzleOrm.eq(subAgentArtifactComponents.projectId, params.scopes.projectId),
-      drizzleOrm.eq(subAgentRelations.graphId, params.scopes.graphId)
+      drizzleOrm.eq(subAgentRelations.agentId, params.scopes.agentId)
     )
   ).limit(1);
   const total = result[0]?.count || 0;
@@ -219230,7 +219175,7 @@ var countArtifactComponentsForAgent = (db) => async (params) => {
     drizzleOrm.and(
       drizzleOrm.eq(subAgentArtifactComponents.tenantId, params.scopes.tenantId),
       drizzleOrm.eq(subAgentArtifactComponents.projectId, params.scopes.projectId),
-      drizzleOrm.eq(subAgentArtifactComponents.graphId, params.scopes.graphId),
+      drizzleOrm.eq(subAgentArtifactComponents.agentId, params.scopes.agentId),
       drizzleOrm.eq(subAgentArtifactComponents.subAgentId, params.scopes.subAgentId)
     )
   );
@@ -219714,7 +219659,7 @@ var getDataComponentsForAgent = (db) => async (params) => {
     drizzleOrm.and(
       drizzleOrm.eq(dataComponents.tenantId, params.scopes.tenantId),
       drizzleOrm.eq(dataComponents.projectId, params.scopes.projectId),
-      drizzleOrm.eq(subAgentDataComponents.graphId, params.scopes.graphId),
+      drizzleOrm.eq(subAgentDataComponents.agentId, params.scopes.agentId),
       drizzleOrm.eq(subAgentDataComponents.subAgentId, params.scopes.subAgentId)
     )
   ).orderBy(drizzleOrm.desc(dataComponents.createdAt));
@@ -219724,7 +219669,7 @@ var associateDataComponentWithAgent = (db) => async (params) => {
     id: nanoid.nanoid(),
     tenantId: params.scopes.tenantId,
     projectId: params.scopes.projectId,
-    graphId: params.scopes.graphId,
+    agentId: params.scopes.agentId,
     subAgentId: params.scopes.subAgentId,
     dataComponentId: params.dataComponentId
   }).returning();
@@ -219735,7 +219680,7 @@ var removeDataComponentFromAgent = (db) => async (params) => {
     drizzleOrm.and(
       drizzleOrm.eq(subAgentDataComponents.tenantId, params.scopes.tenantId),
       drizzleOrm.eq(subAgentDataComponents.projectId, params.scopes.projectId),
-      drizzleOrm.eq(subAgentDataComponents.graphId, params.scopes.graphId),
+      drizzleOrm.eq(subAgentDataComponents.agentId, params.scopes.agentId),
       drizzleOrm.eq(subAgentDataComponents.subAgentId, params.scopes.subAgentId),
       drizzleOrm.eq(subAgentDataComponents.dataComponentId, params.dataComponentId)
     )
@@ -219746,7 +219691,7 @@ var deleteAgentDataComponentRelationByAgent = (db) => async (params) => {
   const result = await db.delete(subAgentDataComponents).where(
     drizzleOrm.and(
       drizzleOrm.eq(subAgentDataComponents.tenantId, params.scopes.tenantId),
-      drizzleOrm.eq(subAgentDataComponents.graphId, params.scopes.graphId),
+      drizzleOrm.eq(subAgentDataComponents.agentId, params.scopes.agentId),
       drizzleOrm.eq(subAgentDataComponents.subAgentId, params.scopes.subAgentId)
     )
   );
@@ -219769,7 +219714,7 @@ var isDataComponentAssociatedWithAgent = (db) => async (params) => {
     drizzleOrm.and(
       drizzleOrm.eq(subAgentDataComponents.tenantId, params.scopes.tenantId),
       drizzleOrm.eq(subAgentDataComponents.projectId, params.scopes.projectId),
-      drizzleOrm.eq(subAgentDataComponents.graphId, params.scopes.graphId),
+      drizzleOrm.eq(subAgentDataComponents.agentId, params.scopes.agentId),
       drizzleOrm.eq(subAgentDataComponents.subAgentId, params.scopes.subAgentId),
       drizzleOrm.eq(subAgentDataComponents.dataComponentId, params.dataComponentId)
     )
@@ -219814,24 +219759,24 @@ var upsertDataComponent = (db) => async (params) => {
   }
 };
 
-// src/validation/graphFull.ts
+// src/validation/agentFull.ts
 function isInternalAgent(agent) {
   return "prompt" in agent;
 }
 function isExternalAgent(agent) {
   return "baseUrl" in agent;
 }
-function validateAndTypeGraphData(data) {
-  return GraphWithinContextOfProjectSchema.parse(data);
+function validateAndTypeAgentData(data) {
+  return AgentWithinContextOfProjectSchema.parse(data);
 }
-function validateToolReferences(graphData, availableToolIds) {
+function validateToolReferences(agentData, availableToolIds) {
   if (!availableToolIds) {
     return;
   }
   const errors = [];
-  for (const [subAgentId, agentData] of Object.entries(graphData.subAgents)) {
-    if (isInternalAgent(agentData) && agentData.canUse && Array.isArray(agentData.canUse)) {
-      for (const canUseItem of agentData.canUse) {
+  for (const [subAgentId, subAgent] of Object.entries(agentData.subAgents)) {
+    if (isInternalAgent(subAgent) && subAgent.canUse && Array.isArray(subAgent.canUse)) {
+      for (const canUseItem of subAgent.canUse) {
         if (!availableToolIds.has(canUseItem.toolId)) {
           errors.push(`Agent '${subAgentId}' references non-existent tool '${canUseItem.toolId}'`);
         }
@@ -219843,14 +219788,14 @@ function validateToolReferences(graphData, availableToolIds) {
 ${errors.join("\n")}`);
   }
 }
-function validateDataComponentReferences(graphData, availableDataComponentIds) {
+function validateDataComponentReferences(agentData, availableDataComponentIds) {
   if (!availableDataComponentIds) {
     return;
   }
   const errors = [];
-  for (const [subAgentId, agentData] of Object.entries(graphData.subAgents)) {
-    if (isInternalAgent(agentData) && agentData.dataComponents) {
-      for (const dataComponentId of agentData.dataComponents) {
+  for (const [subAgentId, subAgent] of Object.entries(agentData.subAgents)) {
+    if (isInternalAgent(subAgent) && subAgent.dataComponents) {
+      for (const dataComponentId of subAgent.dataComponents) {
         if (!availableDataComponentIds.has(dataComponentId)) {
           errors.push(
             `Agent '${subAgentId}' references non-existent dataComponent '${dataComponentId}'`
@@ -219864,14 +219809,14 @@ function validateDataComponentReferences(graphData, availableDataComponentIds) {
 ${errors.join("\n")}`);
   }
 }
-function validateArtifactComponentReferences(graphData, availableArtifactComponentIds) {
+function validateArtifactComponentReferences(agentData, availableArtifactComponentIds) {
   if (!availableArtifactComponentIds) {
     return;
   }
   const errors = [];
-  for (const [subAgentId, agentData] of Object.entries(graphData.subAgents)) {
-    if (isInternalAgent(agentData) && agentData.artifactComponents) {
-      for (const artifactComponentId of agentData.artifactComponents) {
+  for (const [subAgentId, subAgent] of Object.entries(agentData.subAgents)) {
+    if (isInternalAgent(subAgent) && subAgent.artifactComponents) {
+      for (const artifactComponentId of subAgent.artifactComponents) {
         if (!availableArtifactComponentIds.has(artifactComponentId)) {
           errors.push(
             `Agent '${subAgentId}' references non-existent artifactComponent '${artifactComponentId}'`
@@ -219885,25 +219830,25 @@ function validateArtifactComponentReferences(graphData, availableArtifactCompone
 ${errors.join("\n")}`);
   }
 }
-function validateAgentRelationships(graphData) {
+function validateAgentRelationships(agentData) {
   const errors = [];
-  const availableAgentIds = new Set(Object.keys(graphData.subAgents));
-  for (const [subAgentId, agentData] of Object.entries(graphData.subAgents)) {
-    if (isInternalAgent(agentData)) {
-      if (agentData.canTransferTo && Array.isArray(agentData.canTransferTo)) {
-        for (const targetId of agentData.canTransferTo) {
+  const availableAgentIds = new Set(Object.keys(agentData.subAgents));
+  for (const [subAgentId, subAgent] of Object.entries(agentData.subAgents)) {
+    if (isInternalAgent(subAgent)) {
+      if (subAgent.canTransferTo && Array.isArray(subAgent.canTransferTo)) {
+        for (const targetId of subAgent.canTransferTo) {
           if (!availableAgentIds.has(targetId)) {
             errors.push(
-              `Agent '${subAgentId}' has transfer target '${targetId}' that doesn't exist in graph`
+              `Agent '${subAgentId}' has transfer target '${targetId}' that doesn't exist in agent`
             );
           }
         }
       }
-      if (agentData.canDelegateTo && Array.isArray(agentData.canDelegateTo)) {
-        for (const targetId of agentData.canDelegateTo) {
+      if (subAgent.canDelegateTo && Array.isArray(subAgent.canDelegateTo)) {
+        for (const targetId of subAgent.canDelegateTo) {
           if (!availableAgentIds.has(targetId)) {
             errors.push(
-              `Agent '${subAgentId}' has delegation target '${targetId}' that doesn't exist in graph`
+              `Agent '${subAgentId}' has delegation target '${targetId}' that doesn't exist in agent`
             );
           }
         }
@@ -219915,26 +219860,26 @@ function validateAgentRelationships(graphData) {
 ${errors.join("\n")}`);
   }
 }
-function validateGraphStructure(graphData, projectResources) {
-  if (graphData.defaultSubAgentId && !graphData.subAgents[graphData.defaultSubAgentId]) {
-    throw new Error(`Default agent '${graphData.defaultSubAgentId}' does not exist in agents`);
+function validateAgentStructure(agentData, projectResources) {
+  if (agentData.defaultSubAgentId && !agentData.subAgents[agentData.defaultSubAgentId]) {
+    throw new Error(`Default agent '${agentData.defaultSubAgentId}' does not exist in agents`);
   }
   if (projectResources) {
-    validateToolReferences(graphData, projectResources.toolIds);
-    validateDataComponentReferences(graphData, projectResources.dataComponentIds);
-    validateArtifactComponentReferences(graphData, projectResources.artifactComponentIds);
+    validateToolReferences(agentData, projectResources.toolIds);
+    validateDataComponentReferences(agentData, projectResources.dataComponentIds);
+    validateArtifactComponentReferences(agentData, projectResources.artifactComponentIds);
   }
-  validateAgentRelationships(graphData);
+  validateAgentRelationships(agentData);
 }
 
-// src/data-access/graphFull.ts
+// src/data-access/agentFull.ts
 var defaultLogger = {
   info: () => {
   },
   error: () => {
   }
 };
-async function applyExecutionLimitsInheritance(db, logger14, scopes, graphData) {
+async function applyExecutionLimitsInheritance(db, logger14, scopes, agentData) {
   const { tenantId, projectId } = scopes;
   try {
     const project = await db.query.projects.findFirst({
@@ -219952,27 +219897,27 @@ async function applyExecutionLimitsInheritance(db, logger14, 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;
       logger14.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;
       logger14.info(
         {
-          graphId: graphData.id,
+          agentId: agentData.id,
           defaultValue: 10
         },
-        "Graph set to default transferCountIs"
+        "Agent set to default transferCountIs"
       );
     }
     if (projectStopWhen?.stepCountIs !== void 0) {
@@ -219983,8 +219928,8 @@ async function applyExecutionLimitsInheritance(db, logger14, 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 = {};
@@ -220012,24 +219957,24 @@ async function applyExecutionLimitsInheritance(db, logger14, scopes, graphData)
     );
   }
 }
-var createFullGraphServerSide = (db, logger14 = defaultLogger) => async (scopes, graphData) => {
+var createFullAgentServerSide = (db, logger14 = defaultLogger) => async (scopes, agentData) => {
   const { tenantId, projectId } = scopes;
-  const typed = validateAndTypeGraphData(graphData);
-  validateGraphStructure(typed);
+  const typed = validateAndTypeAgentData(agentData);
+  validateAgentStructure(typed);
   await applyExecutionLimitsInheritance(db, logger14, { tenantId, projectId }, typed);
   try {
     logger14.info(
       {},
-      "CredentialReferences are project-scoped - skipping credential reference creation in graph"
+      "CredentialReferences are project-scoped - skipping credential reference creation in agent"
     );
-    logger14.info({}, "MCP Tools are project-scoped - skipping tool creation in graph");
-    let finalGraphId;
+    logger14.info({}, "MCP Tools are project-scoped - skipping tool creation in agent");
+    let finalAgentId;
     try {
-      const graphId = typed.id || nanoid.nanoid();
-      logger14.info({ graphId }, "Creating agent graph metadata");
-      const agentGraph2 = await upsertAgentGraph(db)({
+      const agentId = typed.id || nanoid.nanoid();
+      logger14.info({ agentId }, "Creating agent metadata");
+      const agent = await upsertAgent(db)({
         data: {
-          id: graphId,
+          id: agentId,
           tenantId,
           projectId,
           name: typed.name,
@@ -220039,14 +219984,17 @@ var createFullGraphServerSide = (db, logger14 = 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;
-      logger14.info({ graphId: finalGraphId }, "Agent graph metadata created successfully");
+      if (!agent?.id) {
+        throw new Error("Failed to create agent: no ID returned");
+      }
+      finalAgentId = agent.id;
+      logger14.info({ agentId: finalAgentId }, "Agent metadata created successfully");
     } catch (error) {
-      logger14.error({ graphId: typed.id, error }, "Failed to create/update graph metadata");
+      logger14.error({ agentId: typed.id, error }, "Failed to create/update agent metadata");
       throw error;
     }
     let contextConfigId;
@@ -220056,7 +220004,7 @@ var createFullGraphServerSide = (db, logger14 = defaultLogger) => async (scopes,
         const contextConfig2 = await upsertContextConfig(db)({
           data: {
             ...typed.contextConfig,
-            graphId: finalGraphId,
+            agentId: finalAgentId,
             tenantId,
             projectId
           }
@@ -220074,12 +220022,12 @@ var createFullGraphServerSide = (db, logger14 = defaultLogger) => async (scopes,
     if (contextConfigId) {
       try {
         logger14.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,
@@ -220088,42 +220036,42 @@ var createFullGraphServerSide = (db, logger14 = defaultLogger) => async (scopes,
             contextConfigId,
             models: typed.models,
             statusUpdates: typed.statusUpdates,
-            graphPrompt: typed.graphPrompt,
+            prompt: typed.prompt,
             stopWhen: typed.stopWhen
           }
         });
         logger14.info(
-          { graphId: finalGraphId, contextConfigId },
-          "Graph updated with contextConfigId successfully"
+          { agentId: finalAgentId, contextConfigId },
+          "Agent updated with contextConfigId successfully"
         );
       } catch (error) {
         logger14.error(
-          { graphId: finalGraphId, contextConfigId, error },
-          "Failed to update graph with contextConfigId"
+          { agentId: finalAgentId, contextConfigId, error },
+          "Failed to update agent with contextConfigId"
         );
         throw error;
       }
     }
     logger14.info(
       {},
-      "DataComponents are project-scoped - skipping dataComponent creation in graph"
+      "DataComponents are project-scoped - skipping dataComponent creation in agent"
     );
     logger14.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) {
       logger14.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 {
-            logger14.info({ graphId: finalGraphId, functionId }, "Creating function for graph");
+            logger14.info({ agentId: finalAgentId, functionId }, "Creating function for agent");
             await upsertFunction(db)({
               data: {
                 ...functionData,
@@ -220131,11 +220079,11 @@ var createFullGraphServerSide = (db, logger14 = defaultLogger) => async (scopes,
               },
               scopes: { tenantId, projectId }
             });
-            logger14.info({ graphId: finalGraphId, functionId }, "Function created successfully");
+            logger14.info({ agentId: finalAgentId, functionId }, "Function created successfully");
           } catch (error) {
             logger14.error(
-              { graphId: finalGraphId, functionId, error },
-              "Failed to create function for graph"
+              { agentId: finalAgentId, functionId, error },
+              "Failed to create function for agent"
             );
             throw error;
           }
@@ -220144,7 +220092,7 @@ var createFullGraphServerSide = (db, logger14 = defaultLogger) => async (scopes,
       await Promise.all(functionPromises);
       logger14.info(
         {
-          graphId: finalGraphId,
+          agentId: finalAgentId,
           functionCount: Object.keys(typed.functions).length
         },
         "All functions created successfully"
@@ -220153,33 +220101,33 @@ var createFullGraphServerSide = (db, logger14 = defaultLogger) => async (scopes,
     if (typed.functionTools && Object.keys(typed.functionTools).length > 0) {
       logger14.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 {
             logger14.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 }
             });
             logger14.info(
-              { graphId: finalGraphId, functionToolId },
+              { agentId: finalAgentId, functionToolId },
               "Function tool created successfully"
             );
           } catch (error) {
             logger14.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;
           }
@@ -220188,14 +220136,14 @@ var createFullGraphServerSide = (db, logger14 = defaultLogger) => async (scopes,
       await Promise.all(functionToolPromises);
       logger14.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 {
         logger14.info({ subAgentId }, "Processing internal agent");
         await upsertSubAgent(db)({
@@ -220203,7 +220151,7 @@ var createFullGraphServerSide = (db, logger14 = defaultLogger) => async (scopes,
             id: subAgentId,
             tenantId,
             projectId,
-            graphId: finalGraphId,
+            agentId: finalAgentId,
             name: internalAgent.name || "",
             description: internalAgent.description || "",
             prompt: internalAgent.prompt || "",
@@ -220220,11 +220168,11 @@ var createFullGraphServerSide = (db, logger14 = defaultLogger) => async (scopes,
     });
     await Promise.all(internalAgentPromises);
     const internalAgentCount = Object.entries(typed.subAgents).filter(
-      ([_, agentData]) => isInternalAgent(agentData)
+      ([_, agentData2]) => isInternalAgent(agentData2)
     ).length;
     logger14.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 {
         logger14.info({ subAgentId }, "Processing external agent");
         await upsertExternalAgent(db)({
@@ -220232,7 +220180,7 @@ var createFullGraphServerSide = (db, logger14 = defaultLogger) => async (scopes,
             id: subAgentId,
             tenantId,
             projectId,
-            graphId: finalGraphId,
+            agentId: finalAgentId,
             name: externalAgent.name,
             description: externalAgent.description || "",
             baseUrl: externalAgent.baseUrl,
@@ -220248,32 +220196,32 @@ var createFullGraphServerSide = (db, logger14 = defaultLogger) => async (scopes,
     });
     await Promise.all(externalAgentPromises);
     const externalAgentCount = Object.entries(typed.subAgents).filter(
-      ([_, agentData]) => isExternalAgent(agentData)
+      ([_, agentData2]) => isExternalAgent(agentData2)
     ).length;
     logger14.info({ externalAgentCount }, "All external agents created/updated successfully");
     if (contextConfigId) {
       try {
         logger14.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 }
         });
-        logger14.info({ graphId: finalGraphId }, "Graph updated with context config");
+        logger14.info({ agentId: finalAgentId }, "Agent updated with context config");
       } catch (error) {
         logger14.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 {
@@ -220292,7 +220240,7 @@ var createFullGraphServerSide = (db, logger14 = defaultLogger) => async (scopes,
                 if (isFunctionTool) {
                   logger14.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
@@ -220304,7 +220252,7 @@ var createFullGraphServerSide = (db, logger14 = defaultLogger) => async (scopes,
                 } else {
                   logger14.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,
@@ -220333,9 +220281,9 @@ var createFullGraphServerSide = (db, logger14 = 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 {
@@ -220344,7 +220292,7 @@ var createFullGraphServerSide = (db, logger14 = defaultLogger) => async (scopes,
                   "Processing agent-data component relation"
                 );
                 await upsertAgentDataComponentRelation(db)({
-                  scopes: { tenantId, projectId, graphId: finalGraphId, subAgentId },
+                  scopes: { tenantId, projectId, agentId: finalAgentId, subAgentId },
                   dataComponentId
                 });
                 logger14.info(
@@ -220365,9 +220313,9 @@ var createFullGraphServerSide = (db, logger14 = defaultLogger) => async (scopes,
     await Promise.all(agentDataComponentPromises);
     logger14.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 {
@@ -220376,7 +220324,7 @@ var createFullGraphServerSide = (db, logger14 = defaultLogger) => async (scopes,
                   "Processing agent-artifact component relation"
                 );
                 await upsertAgentArtifactComponentRelation(db)({
-                  scopes: { tenantId, projectId, graphId: finalGraphId, subAgentId },
+                  scopes: { tenantId, projectId, agentId: finalAgentId, subAgentId },
                   artifactComponentId
                 });
                 logger14.info(
@@ -220397,9 +220345,9 @@ var createFullGraphServerSide = (db, logger14 = defaultLogger) => async (scopes,
     await Promise.all(agentArtifactComponentPromises);
     logger14.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 {
@@ -220411,7 +220359,7 @@ var createFullGraphServerSide = (db, logger14 = defaultLogger) => async (scopes,
                   id: nanoid.nanoid(),
                   tenantId,
                   projectId,
-                  graphId: finalGraphId,
+                  agentId: finalAgentId,
                   sourceSubAgentId: subAgentId,
                   targetSubAgentId,
                   relationType: "transfer"
@@ -220430,8 +220378,8 @@ var createFullGraphServerSide = (db, logger14 = 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(
@@ -220445,7 +220393,7 @@ var createFullGraphServerSide = (db, logger14 = defaultLogger) => async (scopes,
                   id: nanoid.nanoid(),
                   tenantId,
                   projectId,
-                  graphId: finalGraphId,
+                  agentId: finalAgentId,
                   sourceSubAgentId: subAgentId,
                   targetSubAgentId: isTargetExternal ? void 0 : targetSubAgentId,
                   externalSubAgentId: isTargetExternal ? targetSubAgentId : void 0,
@@ -220471,100 +220419,103 @@ var createFullGraphServerSide = (db, logger14 = 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");
     }
-    logger14.info({ tenantId, graphId: finalGraphId }, "Full graph created successfully");
-    return createdGraph;
+    logger14.info({ tenantId, agentId: finalAgentId }, "Full agent created successfully");
+    return createdAgent;
   } catch (error) {
-    const errorGraphId = typed.id || "unknown";
-    logger14.error({ tenantId, graphId: errorGraphId, error }, "Failed to create full graph");
+    const errorAgentId = typed.id || "unknown";
+    logger14.error({ tenantId, agentId: errorAgentId, error }, "Failed to create full agent");
     throw error;
   }
 };
-var updateFullGraphServerSide = (db, logger14 = defaultLogger) => async (scopes, graphData) => {
+var updateFullAgentServerSide = (db, logger14 = 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");
   }
   logger14.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,
     logger14,
     { 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) {
       logger14.info(
-        { graphId: typedGraphDefinition.id },
-        "Graph does not exist, creating new graph"
+        { agentId: typedAgentDefinition.id },
+        "Agent does not exist, creating new agent"
       );
-      return createFullGraphServerSide(db, logger14)(scopes, graphData);
+      return createFullAgentServerSide(db, logger14)(scopes, agentData);
     }
-    const existingGraphModels = existingGraph.models;
+    const existingAgentModels = existingAgent.models;
     logger14.info(
       {},
-      "CredentialReferences are project-scoped - skipping credential reference update in graph"
+      "CredentialReferences are project-scoped - skipping credential reference update in agent"
     );
-    logger14.info({}, "MCP Tools are project-scoped - skipping tool creation in graph update");
-    let finalGraphId;
+    logger14.info({}, "MCP Tools are project-scoped - skipping tool creation in agent update");
+    let finalAgentId;
     try {
-      const graphId = typedGraphDefinition.id || nanoid.nanoid();
-      logger14.info({ graphId }, "Getting/creating agent graph metadata");
-      const agentGraph2 = await upsertAgentGraph(db)({
+      const agentId = typedAgentDefinition.id || nanoid.nanoid();
+      logger14.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;
-      logger14.info({ graphId: finalGraphId }, "Agent graph metadata ready");
+      if (!agent?.id) {
+        throw new Error("Failed to upsert agent: no ID returned");
+      }
+      finalAgentId = agent.id;
+      logger14.info({ agentId: finalAgentId }, "Agent metadata ready");
     } catch (error) {
       logger14.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) {
       logger14.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
           }
@@ -220573,7 +220524,7 @@ var updateFullGraphServerSide = (db, logger14 = defaultLogger) => async (scopes,
         logger14.info({ contextConfigId }, "Context config processed successfully");
       } catch (error) {
         logger14.error(
-          { contextConfigId: typedGraphDefinition.contextConfig.id, error },
+          { contextConfigId: typedAgentDefinition.contextConfig.id, error },
           "Failed to create/update context config"
         );
         throw error;
@@ -220582,53 +220533,53 @@ var updateFullGraphServerSide = (db, logger14 = defaultLogger) => async (scopes,
     if (contextConfigId) {
       try {
         logger14.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
           }
         });
         logger14.info(
-          { graphId: finalGraphId, contextConfigId },
-          "Graph updated with contextConfigId successfully"
+          { agentId: finalAgentId, contextConfigId },
+          "Agent updated with contextConfigId successfully"
         );
       } catch (error) {
         logger14.error(
-          { graphId: finalGraphId, contextConfigId, error },
-          "Failed to update graph with contextConfigId"
+          { agentId: finalAgentId, contextConfigId, error },
+          "Failed to update agent with contextConfigId"
         );
         throw error;
       }
     }
-    logger14.info({}, "DataComponents are project-scoped - skipping dataComponent update in graph");
+    logger14.info({}, "DataComponents are project-scoped - skipping dataComponent update in agent");
     logger14.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) {
       logger14.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 {
-            logger14.info({ graphId: finalGraphId, functionId }, "Updating function for graph");
+            logger14.info({ agentId: finalAgentId, functionId }, "Updating function for agent");
             await upsertFunction(db)({
               data: {
                 ...functionData,
@@ -220636,11 +220587,11 @@ var updateFullGraphServerSide = (db, logger14 = defaultLogger) => async (scopes,
               },
               scopes: { tenantId, projectId }
             });
-            logger14.info({ graphId: finalGraphId, functionId }, "Function updated successfully");
+            logger14.info({ agentId: finalAgentId, functionId }, "Function updated successfully");
           } catch (error) {
             logger14.error(
-              { graphId: finalGraphId, functionId, error },
-              "Failed to update function for graph"
+              { agentId: finalAgentId, functionId, error },
+              "Failed to update function for agent"
             );
             throw error;
           }
@@ -220649,42 +220600,42 @@ var updateFullGraphServerSide = (db, logger14 = defaultLogger) => async (scopes,
       await Promise.all(functionPromises);
       logger14.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) {
       logger14.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 {
             logger14.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 }
             });
             logger14.info(
-              { graphId: finalGraphId, functionToolId },
+              { agentId: finalAgentId, functionToolId },
               "Function tool updated successfully"
             );
           } catch (error) {
             logger14.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;
           }
@@ -220693,17 +220644,17 @@ var updateFullGraphServerSide = (db, logger14 = defaultLogger) => async (scopes,
       await Promise.all(functionToolPromises);
       logger14.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: drizzleOrm.and(
             drizzleOrm.eq(subAgents.id, subAgentId),
             drizzleOrm.eq(subAgents.tenantId, tenantId),
@@ -220716,25 +220667,25 @@ var updateFullGraphServerSide = (db, logger14 = 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];
             logger14.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"
             );
           }
         }
@@ -220747,7 +220698,7 @@ var updateFullGraphServerSide = (db, logger14 = defaultLogger) => async (scopes,
             id: subAgentId,
             tenantId,
             projectId,
-            graphId: finalGraphId,
+            agentId: finalAgentId,
             name: internalAgent.name || "",
             description: internalAgent.description || "",
             prompt: internalAgent.prompt || "",
@@ -220763,12 +220714,12 @@ var updateFullGraphServerSide = (db, logger14 = 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;
     logger14.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 {
         logger14.info({ subAgentId }, "Processing external agent");
         await upsertExternalAgent(db)({
@@ -220776,7 +220727,7 @@ var updateFullGraphServerSide = (db, logger14 = defaultLogger) => async (scopes,
             id: subAgentId,
             tenantId,
             projectId,
-            graphId: finalGraphId,
+            agentId: finalAgentId,
             name: externalAgent.name,
             description: externalAgent.description || "",
             baseUrl: externalAgent.baseUrl,
@@ -220791,23 +220742,23 @@ var updateFullGraphServerSide = (db, logger14 = 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;
     logger14.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++;
@@ -220825,7 +220776,7 @@ var updateFullGraphServerSide = (db, logger14 = 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++;
@@ -220845,34 +220796,34 @@ var updateFullGraphServerSide = (db, logger14 = 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
       }
     });
-    logger14.info({ graphId: typedGraphDefinition.id }, "Graph metadata updated");
+    logger14.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) {
@@ -220880,7 +220831,7 @@ var updateFullGraphServerSide = (db, logger14 = defaultLogger) => async (scopes,
             drizzleOrm.and(
               drizzleOrm.eq(subAgentToolRelations.tenantId, tenantId),
               drizzleOrm.eq(subAgentToolRelations.projectId, projectId),
-              drizzleOrm.eq(subAgentToolRelations.graphId, finalGraphId),
+              drizzleOrm.eq(subAgentToolRelations.agentId, finalAgentId),
               drizzleOrm.eq(subAgentToolRelations.subAgentId, subAgentId)
             )
           );
@@ -220890,7 +220841,7 @@ var updateFullGraphServerSide = (db, logger14 = defaultLogger) => async (scopes,
             drizzleOrm.and(
               drizzleOrm.eq(subAgentToolRelations.tenantId, tenantId),
               drizzleOrm.eq(subAgentToolRelations.projectId, projectId),
-              drizzleOrm.eq(subAgentToolRelations.graphId, finalGraphId),
+              drizzleOrm.eq(subAgentToolRelations.agentId, finalAgentId),
               drizzleOrm.eq(subAgentToolRelations.subAgentId, subAgentId),
               drizzleOrm.not(drizzleOrm.inArray(subAgentToolRelations.id, Array.from(incomingRelationshipIds)))
             )
@@ -220905,18 +220856,18 @@ var updateFullGraphServerSide = (db, logger14 = 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) {
                   logger14.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
@@ -220928,7 +220879,7 @@ var updateFullGraphServerSide = (db, logger14 = defaultLogger) => async (scopes,
                 } else {
                   logger14.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,
@@ -220961,20 +220912,20 @@ var updateFullGraphServerSide = (db, logger14 = 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
                 });
                 logger14.info(
@@ -220997,20 +220948,20 @@ var updateFullGraphServerSide = (db, logger14 = 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
                 });
                 logger14.info(
@@ -221033,22 +220984,22 @@ var updateFullGraphServerSide = (db, logger14 = 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.nanoid(),
-                  graphId: typedGraphDefinition.id || "",
+                  agentId: typedAgentDefinition.id || "",
                   sourceSubAgentId: subAgentId,
                   relationType: "transfer",
                   [targetField]: targetSubAgentId
@@ -221072,9 +221023,9 @@ var updateFullGraphServerSide = (db, logger14 = 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(
@@ -221082,7 +221033,7 @@ var updateFullGraphServerSide = (db, logger14 = defaultLogger) => async (scopes,
               try {
                 const relationData = {
                   id: nanoid.nanoid(),
-                  graphId: typedGraphDefinition.id || "",
+                  agentId: typedAgentDefinition.id || "",
                   sourceSubAgentId: subAgentId,
                   relationType: "delegate",
                   [targetField]: targetSubAgentId
@@ -221109,93 +221060,93 @@ var updateFullGraphServerSide = (db, logger14 = 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");
     }
-    logger14.info({ graphId: typedGraphDefinition.id }, "Full graph updated successfully");
-    return updatedGraph;
+    logger14.info({ agentId: typedAgentDefinition.id }, "Full agent updated successfully");
+    return updatedAgent;
   } catch (error) {
-    logger14.error({ graphId: typedGraphDefinition.id, error }, "Failed to update full graph");
+    logger14.error({ agentId: typedAgentDefinition.id, error }, "Failed to update full agent");
     throw error;
   }
 };
-var getFullGraph = (db, logger14 = defaultLogger) => async (params) => {
+var getFullAgent = (db, logger14 = defaultLogger) => async (params) => {
   const { scopes } = params;
   const { tenantId, projectId } = scopes;
-  logger14.info({ tenantId, graphId: scopes.graphId }, "Retrieving full graph definition");
+  logger14.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) {
-      logger14.info({ tenantId, graphId: scopes.graphId }, "Graph not found");
+    if (!agent) {
+      logger14.info({ tenantId, agentId: scopes.agentId }, "Agent not found");
       return null;
     }
     logger14.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) {
     logger14.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, logger14 = defaultLogger) => async (params) => {
-  const { tenantId, projectId, graphId } = params.scopes;
-  logger14.info({ tenantId, graphId }, "Deleting full graph and related entities");
+var deleteFullAgent = (db, logger14 = defaultLogger) => async (params) => {
+  const { tenantId, projectId, agentId } = params.scopes;
+  logger14.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) {
-      logger14.info({ tenantId, graphId }, "Graph not found for deletion");
+    if (!agent) {
+      logger14.info({ tenantId, agentId }, "Agent not found for deletion");
       return false;
     }
-    await deleteAgentRelationsByGraph(db)({
-      scopes: { tenantId, projectId, graphId }
+    await deleteAgentRelationsByAgent(db)({
+      scopes: { tenantId, projectId, agentId }
     });
-    logger14.info({ tenantId, graphId }, "Agent relations deleted");
-    const subAgentIds = Object.keys(graph.subAgents);
+    logger14.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 }
         });
       }
       logger14.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 }
     });
-    logger14.info({ tenantId, graphId }, "Graph metadata deleted");
-    logger14.info({ tenantId, graphId }, "Full graph deleted successfully");
+    logger14.info({ tenantId, agentId }, "Agent metadata deleted");
+    logger14.info({ tenantId, agentId }, "Full agent deleted successfully");
     return true;
   } catch (error) {
     logger14.error(
       {
         tenantId,
-        graphId,
+        agentId,
         error: error instanceof Error ? error.message : "Unknown error"
       },
-      "Failed to delete full graph"
+      "Failed to delete full agent"
     );
     throw error;
   }
@@ -221578,7 +221529,7 @@ var listProjects = (db) => async (params) => {
   }
   const projectIdSets = await Promise.all([
     db.selectDistinct({ projectId: subAgents.projectId }).from(subAgents).where(drizzleOrm.eq(subAgents.tenantId, params.tenantId)),
-    db.selectDistinct({ projectId: agentGraph.projectId }).from(agentGraph).where(drizzleOrm.eq(agentGraph.tenantId, params.tenantId)),
+    db.selectDistinct({ projectId: agents.projectId }).from(agents).where(drizzleOrm.eq(agents.tenantId, params.tenantId)),
     db.selectDistinct({ projectId: tools.projectId }).from(tools).where(drizzleOrm.eq(tools.tenantId, params.tenantId)),
     db.selectDistinct({ projectId: contextConfigs.projectId }).from(contextConfigs).where(drizzleOrm.eq(contextConfigs.tenantId, params.tenantId)),
     db.selectDistinct({ projectId: externalAgents.projectId }).from(externalAgents).where(drizzleOrm.eq(externalAgents.tenantId, params.tenantId)),
@@ -221624,16 +221575,16 @@ var listProjectsPaginated = (db) => async (params) => {
 };
 var getProjectResourceCounts = (db) => async (params) => {
   const whereClause = (table) => drizzleOrm.and(drizzleOrm.eq(table.tenantId, params.tenantId), drizzleOrm.eq(table.projectId, params.projectId));
-  const [agentResults, graphResults, toolResults, contextConfigResults, externalAgentResults] = await Promise.all([
+  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
@@ -221643,7 +221594,7 @@ var projectExists = (db) => async (params) => {
   const whereClause = (table) => drizzleOrm.and(drizzleOrm.eq(table.tenantId, params.tenantId), drizzleOrm.eq(table.projectId, params.projectId));
   const checks = [
     db.select({ id: 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),
@@ -221725,24 +221676,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: drizzleOrm.and(drizzleOrm.eq(agentGraph.tenantId, tenantId), drizzleOrm.eq(agentGraph.projectId, projectId))
+    const agentsToUpdate = await db.query.agents.findMany({
+      where: drizzleOrm.and(drizzleOrm.eq(agents.tenantId, tenantId), drizzleOrm.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(
           drizzleOrm.and(
-            drizzleOrm.eq(agentGraph.tenantId, tenantId),
-            drizzleOrm.eq(agentGraph.projectId, projectId),
-            drizzleOrm.eq(agentGraph.id, graph.id)
+            drizzleOrm.eq(agents.tenantId, tenantId),
+            drizzleOrm.eq(agents.projectId, projectId),
+            drizzleOrm.eq(agents.id, agent.id)
           )
         );
       }
@@ -221786,7 +221737,7 @@ var createFullProjectServerSide = (db, logger14 = defaultLogger2) => async (scop
     {
       tenantId,
       projectId: typed.id,
-      graphCount: Object.keys(typed.graphs || {}).length
+      agentCount: Object.keys(typed.agents || {}).length
     },
     "Creating full project in database"
   );
@@ -222005,19 +221956,19 @@ var createFullProjectServerSide = (db, logger14 = 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) {
       logger14.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 {
-          logger14.info({ projectId: typed.id, graphId }, "Creating graph in project");
-          const graphDataWithProjectResources = {
-            ...graphData,
+          logger14.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 || {},
@@ -222025,28 +221976,28 @@ var createFullProjectServerSide = (db, logger14 = 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, logger14)(
+          await createFullAgentServerSide(db, logger14)(
             { tenantId, projectId: typed.id },
-            graphDataWithProjectResources
+            agentDataWithProjectResources
           );
-          logger14.info({ projectId: typed.id, graphId }, "Graph created successfully in project");
+          logger14.info({ projectId: typed.id, agentId }, "Agent created successfully in project");
         } catch (error) {
           logger14.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);
       logger14.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"
       );
     }
     logger14.info({ projectId: typed.id }, "Full project created successfully");
@@ -222078,7 +222029,7 @@ var updateFullProjectServerSide = (db, logger14 = defaultLogger2) => async (scop
     {
       tenantId,
       projectId: typed.id,
-      graphCount: Object.keys(typed.graphs || {}).length
+      agentCount: Object.keys(typed.agents || {}).length
     },
     "Updating full project in database"
   );
@@ -222313,52 +222264,52 @@ var updateFullProjectServerSide = (db, logger14 = 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,
             logger14
           )({
-            scopes: { tenantId, projectId: typed.id, graphId: graph.id }
+            scopes: { tenantId, projectId: typed.id, agentId: agent.id }
           });
-          deletedGraphCount++;
-          logger14.info({ graphId: graph.id }, "Deleted orphaned graph from project");
+          deletedAgentCount++;
+          logger14.info({ agentId: agent.id }, "Deleted orphaned agent from project");
         } catch (error) {
           logger14.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) {
       logger14.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) {
       logger14.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 {
-          logger14.info({ projectId: typed.id, graphId }, "Updating graph in project");
-          const graphDataWithProjectResources = {
-            ...graphData,
+          logger14.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 || {},
@@ -222366,28 +222317,28 @@ var updateFullProjectServerSide = (db, logger14 = 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, logger14)(
+          await updateFullAgentServerSide(db, logger14)(
             { tenantId, projectId: typed.id },
-            graphDataWithProjectResources
+            agentDataWithProjectResources
           );
-          logger14.info({ projectId: typed.id, graphId }, "Graph updated successfully in project");
+          logger14.info({ projectId: typed.id, agentId }, "Agent updated successfully in project");
         } catch (error) {
           logger14.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);
       logger14.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"
       );
     }
     logger14.info({ projectId: typed.id }, "Full project updated successfully");
@@ -222422,16 +222373,16 @@ var getFullProject = (db, logger14 = defaultLogger2) => async (params) => {
       return null;
     }
     logger14.info({ tenantId, projectId }, "Project metadata retrieved");
-    const graphList = await listAgentGraphs(db)({
+    const agentList = await listAgents(db)({
       scopes: { tenantId, projectId }
     });
     logger14.info(
       {
         tenantId,
         projectId,
-        graphCount: graphList.length
+        agentCount: agentList.length
       },
-      "Found graphs for project"
+      "Found agent for project"
     );
     const projectTools = {};
     try {
@@ -222529,34 +222480,34 @@ var getFullProject = (db, logger14 = 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 {
           logger14.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;
             logger14.info(
-              { tenantId, projectId, graphId: graph.id },
-              "Full graph definition retrieved"
+              { tenantId, projectId, agentId: agent.id },
+              "Full agent definition retrieved"
             );
           } else {
-            logger14.warn({ tenantId, projectId, graphId: graph.id }, "Graph definition not found");
+            logger14.warn({ tenantId, projectId, agentId: agent.id }, "Agent definition not found");
           }
         } catch (error) {
           logger14.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(
@@ -222569,7 +222520,7 @@ var getFullProject = (db, logger14 = defaultLogger2) => async (params) => {
       description: project.description,
       models: project.models,
       stopWhen: project.stopWhen || void 0,
-      graphs,
+      agents: agents2,
       tools: projectTools,
       dataComponents: projectDataComponents,
       artifactComponents: projectArtifactComponents,
@@ -222581,7 +222532,7 @@ var getFullProject = (db, logger14 = defaultLogger2) => async (params) => {
       {
         tenantId,
         projectId,
-        graphCount: Object.keys(fullProjectDefinition.graphs).length
+        agentCount: Object.keys(fullProjectDefinition.agents).length
       },
       "Full project definition retrieved"
     );
@@ -222613,44 +222564,44 @@ var deleteFullProject = (db, logger14 = defaultLogger2) => async (params) => {
       logger14.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) {
       logger14.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 {
-          logger14.info({ tenantId, projectId, graphId }, "Deleting graph from project");
-          await deleteFullGraph(
+          logger14.info({ tenantId, projectId, agentId }, "Deleting agent from project");
+          await deleteFullAgent(
             db,
             logger14
           )({
-            scopes: { tenantId, projectId, graphId }
+            scopes: { tenantId, projectId, agentId }
           });
           logger14.info(
-            { tenantId, projectId, graphId },
-            "Graph deleted successfully from project"
+            { tenantId, projectId, agentId },
+            "Agent deleted successfully from project"
           );
         } catch (error) {
           logger14.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);
       logger14.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)({
@@ -223439,10 +223390,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,
@@ -223450,25 +223398,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) {
-      logger10.debug({ graphId }, "No context config found for graph, skipping validation");
+    if (!agent?.contextConfigId) {
+      logger10.debug({ agentId }, "No context config found for agent, skipping validation");
       return {
         valid: true,
         errors: [],
@@ -223476,11 +223422,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) {
-      logger10.warn({ contextConfigId: agentGraph2.contextConfigId }, "Context config not found");
+      logger10.warn({ contextConfigId: agent.contextConfigId }, "Context config not found");
       return {
         valid: false,
         errors: [
@@ -223548,7 +223494,7 @@ async function validateHeaders({
     logger10.error(
       {
         tenantId,
-        graphId,
+        agentId,
         error: error instanceof Error ? error.message : "Unknown error"
       },
       "Failed to validate headers"
@@ -223568,13 +223514,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") || {};
@@ -223590,7 +223536,7 @@ function contextValidationMiddleware(dbClient) {
       const validationResult = await validateHeaders({
         tenantId,
         projectId,
-        graphId,
+        agentId,
         conversationId,
         parsedRequest,
         dbClient,
@@ -223600,7 +223546,7 @@ function contextValidationMiddleware(dbClient) {
         logger10.warn(
           {
             tenantId,
-            graphId,
+            agentId,
             errors: validationResult.errors
           },
           "Headers validation failed"
@@ -223615,7 +223561,7 @@ function contextValidationMiddleware(dbClient) {
       logger10.debug(
         {
           tenantId,
-          graphId,
+          agentId,
           contextKeys: Object.keys(validationResult.validatedContext || {})
         },
         "Request context validation successful"
@@ -223642,8 +223588,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);
     }
   }
@@ -223988,7 +223934,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
@@ -224000,7 +223946,7 @@ async function handleContextConfigChange(tenantId, projectId, conversationId, gr
     logger12.info(
       {
         conversationId,
-        graphId,
+        agentId,
         contextConfigId: newContextConfigId
       },
       "Potential context config change for existing conversation, cache cleared"
@@ -224010,7 +223956,7 @@ async function handleContextConfigChange(tenantId, projectId, conversationId, gr
 async function handleContextResolution({
   tenantId,
   projectId,
-  graphId,
+  agentId,
   conversationId,
   headers: headers2,
   dbClient,
@@ -224024,38 +223970,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) {
-          logger12.debug({ graphId }, "No context config found for graph");
+        if (!agent?.contextConfigId) {
+          logger12.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) {
           logger12.warn(
-            { contextConfigId: agentGraph2.contextConfigId },
+            { contextConfigId: agent.contextConfigId },
             "Context config not found, proceeding without context resolution"
           );
           parentSpan.setStatus({ code: api.SpanStatusCode.ERROR });
           parentSpan.addEvent("context.config_not_found", {
-            contextConfigId: agentGraph2.contextConfigId
+            contextConfigId: agent.contextConfigId
           });
           return null;
         }
@@ -224094,7 +224040,7 @@ async function handleContextResolution({
         logger12.info(
           {
             conversationId,
-            graphId,
+            agentId,
             contextConfigId: contextConfig2.id,
             trigger,
             resolvedKeys: Object.keys(resolvedContext),
@@ -224103,7 +224049,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) {
@@ -224116,7 +224062,7 @@ async function handleContextResolution({
         logger12.error(
           {
             error: errorMessage,
-            contextConfigId: agentGraph2?.contextConfigId,
+            contextConfigId: agent?.contextConfigId,
             trigger: await determineContextTrigger(
               tenantId,
               projectId,
@@ -225038,12 +224984,14 @@ exports.AGGREGATE_OPERATORS = AGGREGATE_OPERATORS;
 exports.AI_OPERATIONS = AI_OPERATIONS;
 exports.AI_TOOL_TYPES = AI_TOOL_TYPES;
 exports.ANTHROPIC_MODELS = ANTHROPIC_MODELS;
-exports.AgentGraphApiInsertSchema = AgentGraphApiInsertSchema;
-exports.AgentGraphApiSelectSchema = AgentGraphApiSelectSchema;
-exports.AgentGraphApiUpdateSchema = AgentGraphApiUpdateSchema;
-exports.AgentGraphInsertSchema = AgentGraphInsertSchema;
-exports.AgentGraphSelectSchema = AgentGraphSelectSchema;
-exports.AgentGraphUpdateSchema = AgentGraphUpdateSchema;
+exports.AgentApiInsertSchema = AgentApiInsertSchema;
+exports.AgentApiSelectSchema = AgentApiSelectSchema;
+exports.AgentApiUpdateSchema = AgentApiUpdateSchema;
+exports.AgentInsertSchema = AgentInsertSchema;
+exports.AgentSelectSchema = AgentSelectSchema;
+exports.AgentStopWhenSchema = AgentStopWhenSchema;
+exports.AgentUpdateSchema = AgentUpdateSchema;
+exports.AgentWithinContextOfProjectSchema = AgentWithinContextOfProjectSchema;
 exports.AllAgentSchema = AllAgentSchema;
 exports.ApiKeyApiCreationResponseSchema = ApiKeyApiCreationResponseSchema;
 exports.ApiKeyApiInsertSchema = ApiKeyApiInsertSchema;
@@ -225121,8 +225069,7 @@ exports.ExternalSubAgentRelationInsertSchema = ExternalSubAgentRelationInsertSch
 exports.FIELD_TYPES = FIELD_TYPES;
 exports.FetchConfigSchema = FetchConfigSchema;
 exports.FetchDefinitionSchema = FetchDefinitionSchema;
-exports.FullGraphAgentInsertSchema = FullGraphAgentInsertSchema;
-exports.FullGraphDefinitionSchema = FullGraphDefinitionSchema;
+exports.FullAgentAgentInsertSchema = FullAgentAgentInsertSchema;
 exports.FullProjectDefinitionSchema = FullProjectDefinitionSchema;
 exports.FunctionApiInsertSchema = FunctionApiInsertSchema;
 exports.FunctionApiSelectSchema = FunctionApiSelectSchema;
@@ -225138,8 +225085,6 @@ exports.FunctionToolSelectSchema = FunctionToolSelectSchema;
 exports.FunctionToolUpdateSchema = FunctionToolUpdateSchema;
 exports.FunctionUpdateSchema = FunctionUpdateSchema;
 exports.GOOGLE_MODELS = GOOGLE_MODELS;
-exports.GraphStopWhenSchema = GraphStopWhenSchema;
-exports.GraphWithinContextOfProjectSchema = GraphWithinContextOfProjectSchema;
 exports.HTTP_REQUEST_PARTS = HTTP_REQUEST_PARTS;
 exports.HeadersScopeSchema = HeadersScopeSchema;
 exports.InMemoryCredentialStore = InMemoryCredentialStore;
@@ -225247,10 +225192,10 @@ exports.TaskUpdateSchema = TaskUpdateSchema;
 exports.TemplateEngine = TemplateEngine;
 exports.TenantIdParamsSchema = TenantIdParamsSchema;
 exports.TenantParamsSchema = TenantParamsSchema;
-exports.TenantProjectGraphIdParamsSchema = TenantProjectGraphIdParamsSchema;
-exports.TenantProjectGraphParamsSchema = TenantProjectGraphParamsSchema;
-exports.TenantProjectGraphSubAgentIdParamsSchema = TenantProjectGraphSubAgentIdParamsSchema;
-exports.TenantProjectGraphSubAgentParamsSchema = TenantProjectGraphSubAgentParamsSchema;
+exports.TenantProjectAgentIdParamsSchema = TenantProjectAgentIdParamsSchema;
+exports.TenantProjectAgentParamsSchema = TenantProjectAgentParamsSchema;
+exports.TenantProjectAgentSubAgentIdParamsSchema = TenantProjectAgentSubAgentIdParamsSchema;
+exports.TenantProjectAgentSubAgentParamsSchema = TenantProjectAgentSubAgentParamsSchema;
 exports.TenantProjectIdParamsSchema = TenantProjectIdParamsSchema;
 exports.TenantProjectParamsSchema = TenantProjectParamsSchema;
 exports.ToolApiInsertSchema = ToolApiInsertSchema;
@@ -225269,9 +225214,10 @@ exports.addLedgerArtifacts = addLedgerArtifacts;
 exports.addToolToAgent = addToolToAgent;
 exports.agentFunctionToolRelations = agentFunctionToolRelations;
 exports.agentFunctionToolRelationsRelations = agentFunctionToolRelationsRelations;
-exports.agentGraph = agentGraph;
-exports.agentGraphRelations = agentGraphRelations;
+exports.agentHasArtifactComponents = agentHasArtifactComponents;
+exports.agentRelations = agentRelations;
 exports.agentToolRelationsRelations = agentToolRelationsRelations;
+exports.agents = agents;
 exports.apiFetch = apiFetch;
 exports.apiKeys = apiKeys;
 exports.apiKeysRelations = apiKeysRelations;
@@ -225306,7 +225252,7 @@ exports.countExternalAgents = countExternalAgents;
 exports.countLedgerArtifactsByTask = countLedgerArtifactsByTask;
 exports.countMessagesByConversation = countMessagesByConversation;
 exports.countProjects = countProjects;
-exports.createAgentGraph = createAgentGraph;
+exports.createAgent = createAgent;
 exports.createAgentToolRelation = createAgentToolRelation;
 exports.createApiError = createApiError;
 exports.createApiKey = createApiKey;
@@ -225320,7 +225266,7 @@ exports.createDefaultCredentialStores = createDefaultCredentialStores;
 exports.createExecutionContext = createExecutionContext;
 exports.createExternalAgent = createExternalAgent;
 exports.createExternalAgentRelation = createExternalAgentRelation;
-exports.createFullGraphServerSide = createFullGraphServerSide;
+exports.createFullAgentServerSide = createFullAgentServerSide;
 exports.createFullProjectServerSide = createFullProjectServerSide;
 exports.createFunctionTool = createFunctionTool;
 exports.createInMemoryDatabaseClient = createInMemoryDatabaseClient;
@@ -225339,10 +225285,10 @@ exports.credentialReferencesRelations = credentialReferencesRelations;
 exports.dataComponents = dataComponents;
 exports.dataComponentsRelations = dataComponentsRelations;
 exports.dbResultToMcpTool = dbResultToMcpTool;
+exports.deleteAgent = deleteAgent;
 exports.deleteAgentArtifactComponentRelationByAgent = deleteAgentArtifactComponentRelationByAgent;
 exports.deleteAgentDataComponentRelationByAgent = deleteAgentDataComponentRelationByAgent;
-exports.deleteAgentGraph = deleteAgentGraph;
-exports.deleteAgentRelationsByGraph = deleteAgentRelationsByGraph;
+exports.deleteAgentRelationsByAgent = deleteAgentRelationsByAgent;
 exports.deleteAgentToolRelation = deleteAgentToolRelation;
 exports.deleteAgentToolRelationByAgent = deleteAgentToolRelationByAgent;
 exports.deleteApiKey = deleteApiKey;
@@ -225352,7 +225298,7 @@ exports.deleteConversation = deleteConversation;
 exports.deleteCredentialReference = deleteCredentialReference;
 exports.deleteDataComponent = deleteDataComponent;
 exports.deleteExternalAgent = deleteExternalAgent;
-exports.deleteFullGraph = deleteFullGraph;
+exports.deleteFullAgent = deleteFullAgent;
 exports.deleteFullProject = deleteFullProject;
 exports.deleteFunction = deleteFunction;
 exports.deleteFunctionTool = deleteFunctionTool;
@@ -225385,17 +225331,18 @@ exports.generateApiKey = generateApiKey;
 exports.generateId = generateId;
 exports.generateIdFromName = generateIdFromName;
 exports.getActiveAgentForConversation = getActiveAgentForConversation;
-exports.getAgentGraphById = getAgentGraphById;
-exports.getAgentGraphWithDefaultSubAgent = getAgentGraphWithDefaultSubAgent;
+exports.getAgentById = getAgentById;
 exports.getAgentRelationById = getAgentRelationById;
 exports.getAgentRelationByParams = getAgentRelationByParams;
 exports.getAgentRelations = getAgentRelations;
-exports.getAgentRelationsByGraph = getAgentRelationsByGraph;
+exports.getAgentRelationsByAgent = getAgentRelationsByAgent;
 exports.getAgentRelationsBySource = getAgentRelationsBySource;
 exports.getAgentRelationsByTarget = getAgentRelationsByTarget;
+exports.getAgentSubAgentInfos = getAgentSubAgentInfos;
 exports.getAgentToolRelationByAgent = getAgentToolRelationByAgent;
 exports.getAgentToolRelationById = getAgentToolRelationById;
 exports.getAgentToolRelationByTool = getAgentToolRelationByTool;
+exports.getAgentWithDefaultSubAgent = getAgentWithDefaultSubAgent;
 exports.getAgentsForTool = getAgentsForTool;
 exports.getAgentsUsingArtifactComponent = getAgentsUsingArtifactComponent;
 exports.getAgentsUsingDataComponent = getAgentsUsingDataComponent;
@@ -225420,13 +225367,12 @@ exports.getDataComponentsForAgent = getDataComponentsForAgent;
 exports.getExternalAgent = getExternalAgent;
 exports.getExternalAgentByUrl = getExternalAgentByUrl;
 exports.getExternalAgentRelations = getExternalAgentRelations;
-exports.getFullGraph = getFullGraph;
-exports.getFullGraphDefinition = getFullGraphDefinition;
+exports.getFullAgent = getFullAgent;
+exports.getFullAgentDefinition = getFullAgentDefinition;
 exports.getFullProject = getFullProject;
 exports.getFunction = getFunction;
 exports.getFunctionToolById = getFunctionToolById;
 exports.getFunctionToolsForSubAgent = getFunctionToolsForSubAgent;
-exports.getGraphAgentInfos = getGraphAgentInfos;
 exports.getLedgerArtifacts = getLedgerArtifacts;
 exports.getLedgerArtifactsByContext = getLedgerArtifactsByContext;
 exports.getLogger = getLogger;
@@ -225435,7 +225381,7 @@ exports.getMessagesByConversation = getMessagesByConversation;
 exports.getMessagesByTask = getMessagesByTask;
 exports.getProject = getProject;
 exports.getProjectResourceCounts = getProjectResourceCounts;
-exports.getRelatedAgentsForGraph = getRelatedAgentsForGraph;
+exports.getRelatedAgentsForAgent = getRelatedAgentsForAgent;
 exports.getRequestExecutionContext = getRequestExecutionContext;
 exports.getSubAgentById = getSubAgentById;
 exports.getSubAgentsByIds = getSubAgentsByIds;
@@ -225444,7 +225390,6 @@ exports.getToolById = getToolById;
 exports.getToolsForAgent = getToolsForAgent;
 exports.getTracer = getTracer;
 exports.getVisibleMessages = getVisibleMessages;
-exports.graphHasArtifactComponents = graphHasArtifactComponents;
 exports.handleApiError = handleApiError;
 exports.handleContextConfigChange = handleContextConfigChange;
 exports.handleContextResolution = handleContextResolution;
@@ -225465,10 +225410,10 @@ exports.isValidResourceId = isValidResourceId;
 exports.isZodSchema = isZodSchema;
 exports.ledgerArtifacts = ledgerArtifacts;
 exports.ledgerArtifactsRelations = ledgerArtifactsRelations;
-exports.listAgentGraphs = listAgentGraphs;
-exports.listAgentGraphsPaginated = listAgentGraphsPaginated;
 exports.listAgentRelations = listAgentRelations;
 exports.listAgentToolRelations = listAgentToolRelations;
+exports.listAgents = listAgents;
+exports.listAgentsPaginated = listAgentsPaginated;
 exports.listApiKeys = listApiKeys;
 exports.listApiKeysPaginated = listApiKeysPaginated;
 exports.listArtifactComponents = listArtifactComponents;
@@ -225526,7 +225471,7 @@ exports.tasks = tasks;
 exports.tasksRelations = tasksRelations;
 exports.tools = tools;
 exports.toolsRelations = toolsRelations;
-exports.updateAgentGraph = updateAgentGraph;
+exports.updateAgent = updateAgent;
 exports.updateAgentRelation = updateAgentRelation;
 exports.updateAgentToolRelation = updateAgentToolRelation;
 exports.updateApiKey = updateApiKey;
@@ -225538,7 +225483,7 @@ exports.updateConversationActiveAgent = updateConversationActiveAgent;
 exports.updateCredentialReference = updateCredentialReference;
 exports.updateDataComponent = updateDataComponent;
 exports.updateExternalAgent = updateExternalAgent;
-exports.updateFullGraphServerSide = updateFullGraphServerSide;
+exports.updateFullAgentServerSide = updateFullAgentServerSide;
 exports.updateFullProjectServerSide = updateFullProjectServerSide;
 exports.updateFunctionTool = updateFunctionTool;
 exports.updateMessage = updateMessage;
@@ -225547,9 +225492,9 @@ exports.updateSubAgent = updateSubAgent;
 exports.updateSubAgentFunctionToolRelation = updateSubAgentFunctionToolRelation;
 exports.updateTask = updateTask;
 exports.updateTool = updateTool;
+exports.upsertAgent = upsertAgent;
 exports.upsertAgentArtifactComponentRelation = upsertAgentArtifactComponentRelation;
 exports.upsertAgentDataComponentRelation = upsertAgentDataComponentRelation;
-exports.upsertAgentGraph = upsertAgentGraph;
 exports.upsertAgentRelation = upsertAgentRelation;
 exports.upsertArtifactComponent = upsertArtifactComponent;
 exports.upsertContextConfig = upsertContextConfig;
@@ -225565,13 +225510,13 @@ exports.upsertSubAgentToolRelation = upsertSubAgentToolRelation;
 exports.upsertTool = upsertTool;
 exports.validateAgainstJsonSchema = validateAgainstJsonSchema;
 exports.validateAgentRelationships = validateAgentRelationships;
+exports.validateAgentStructure = validateAgentStructure;
 exports.validateAndGetApiKey = validateAndGetApiKey;
-exports.validateAndTypeGraphData = validateAndTypeGraphData;
+exports.validateAndTypeAgentData = validateAndTypeAgentData;
 exports.validateApiKey = validateApiKey;
 exports.validateArtifactComponentReferences = validateArtifactComponentReferences;
 exports.validateDataComponentReferences = validateDataComponentReferences;
 exports.validateExternalAgent = validateExternalAgent;
-exports.validateGraphStructure = validateGraphStructure;
 exports.validateHeaders = validateHeaders;
 exports.validateHttpRequestHeaders = validateHttpRequestHeaders;
 exports.validateInternalSubAgent = validateInternalSubAgent;