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

package/dist/index.d.cts

@@ -1,7 +1,36 @@
-import { MCPToolConfig as MCPToolConfig$1, ArtifactComponentInsert, CredentialReferenceApiInsert, DataComponentInsert, CredentialReferenceSelect, FunctionToolConfig, SubAgentApiInsert, DataComponentApiInsert, ArtifactComponentApiInsert, AgentConversationHistoryConfig, GraphStopWhen, ModelSettings, StatusUpdateSettings, FullGraphDefinition, ToolInsert, McpTransportConfig, StopWhen, SandboxConfig, FullProjectDefinition } from '@inkeep/agents-core';
+import { ArtifactComponentInsert, MCPToolConfig as MCPToolConfig$1, CredentialReferenceApiInsert, DataComponentInsert, CredentialReferenceSelect, FunctionToolConfig, SubAgentApiInsert, DataComponentApiInsert, ArtifactComponentApiInsert, AgentConversationHistoryConfig, AgentStopWhen, ModelSettings, StatusUpdateSettings, FullAgentDefinition, ToolInsert, McpTransportConfig, StopWhen, SandboxConfig, FullProjectDefinition } from '@inkeep/agents-core';
 export { ANTHROPIC_MODELS, FunctionToolConfig, GOOGLE_MODELS, ModelSettings, OPENAI_MODELS, SandboxConfig } from '@inkeep/agents-core';
 import { z } from 'zod';
 
+type ArtifactComponentConfigWithZod = Omit<ArtifactComponentInsert, 'tenantId' | 'projectId' | 'props'> & {
+    props?: Record<string, unknown> | z.ZodObject<any> | null;
+};
+interface ArtifactComponentInterface {
+    config: Omit<ArtifactComponentInsert, 'tenantId' | 'projectId'>;
+    init(): Promise<void>;
+    getId(): ArtifactComponentInsert['id'];
+    getName(): ArtifactComponentInsert['name'];
+    getDescription(): ArtifactComponentInsert['description'];
+    getProps(): ArtifactComponentInsert['props'];
+    setContext(tenantId: string, projectId: string, baseURL?: string): void;
+}
+declare class ArtifactComponent implements ArtifactComponentInterface {
+    config: Omit<ArtifactComponentInsert, 'tenantId' | 'projectId'>;
+    private baseURL;
+    private tenantId;
+    private projectId;
+    private initialized;
+    private id;
+    constructor(config: ArtifactComponentConfigWithZod);
+    setContext(tenantId: string, projectId: string, baseURL?: string): void;
+    getId(): string;
+    getName(): string;
+    getDescription(): string;
+    getProps(): ArtifactComponentInsert['props'];
+    init(): Promise<void>;
+    private upsertArtifactComponent;
+}
+
 interface ToolInterface {
     config: MCPToolConfig$1;
     init(): Promise<void>;
@@ -32,35 +61,6 @@ declare class Tool implements ToolInterface {
     private upsertTool;
 }
 
-type ArtifactComponentConfigWithZod = Omit<ArtifactComponentInsert, 'tenantId' | 'projectId' | 'props'> & {
-    props?: Record<string, unknown> | z.ZodObject<any> | null;
-};
-interface ArtifactComponentInterface {
-    config: Omit<ArtifactComponentInsert, 'tenantId' | 'projectId'>;
-    init(): Promise<void>;
-    getId(): ArtifactComponentInsert['id'];
-    getName(): ArtifactComponentInsert['name'];
-    getDescription(): ArtifactComponentInsert['description'];
-    getProps(): ArtifactComponentInsert['props'];
-    setContext(tenantId: string, projectId: string, baseURL?: string): void;
-}
-declare class ArtifactComponent implements ArtifactComponentInterface {
-    config: Omit<ArtifactComponentInsert, 'tenantId' | 'projectId'>;
-    private baseURL;
-    private tenantId;
-    private projectId;
-    private initialized;
-    private id;
-    constructor(config: ArtifactComponentConfigWithZod);
-    setContext(tenantId: string, projectId: string, baseURL?: string): void;
-    getId(): string;
-    getName(): string;
-    getDescription(): string;
-    getProps(): ArtifactComponentInsert['props'];
-    init(): Promise<void>;
-    private upsertArtifactComponent;
-}
-
 /**
  * Function signature for transfer conditions
  */
@@ -100,7 +100,7 @@ type AgentMcpConfig = {
     headers?: Record<string, string>;
 };
 /**
- * Creates a transfer configuration for agent handoffs.
+ * Creates a transfer configuration for agent transfers.
  *
  * Transfers allow one agent to hand off control to another agent
  * based on optional conditions.
@@ -113,7 +113,7 @@ type AgentMcpConfig = {
  * @example
  * ```typescript
  * // Simple transfer
- * const handoff = transfer(supportAgent, 'Transfer to support');
+ * const transfer = transfer(supportAgent, 'Transfer to support');
  *
  * // Conditional transfer
  * const conditionalHandoff = transfer(
@@ -406,7 +406,7 @@ interface RunResult {
         transfers: TransferConfig[];
     };
 }
-interface GraphConfig {
+interface AgentConfig {
     id: string;
     name?: string;
     description?: string;
@@ -414,8 +414,8 @@ interface GraphConfig {
     subAgents?: () => AllSubAgentInterface[];
     contextConfig?: any;
     credentials?: () => CredentialReferenceApiInsert[];
-    stopWhen?: GraphStopWhen;
-    graphPrompt?: string;
+    stopWhen?: AgentStopWhen;
+    agentPrompt?: string;
     models?: {
         base?: ModelSettings;
         structuredOutput?: ModelSettings;
@@ -467,7 +467,7 @@ interface ExternalAgentInterface {
     getHeaders(): Record<string, string> | undefined;
     setContext?(tenantId: string, baseURL?: string): void;
 }
-interface GraphInterface {
+interface AgentInterface {
     init(): Promise<void>;
     setConfig(tenantId: string, projectId: string, apiUrl: string): void;
     getId(): string;
@@ -477,10 +477,10 @@ interface GraphInterface {
     generate(input: MessageInput, options?: GenerateOptions): Promise<string>;
     stream(input: MessageInput, options?: GenerateOptions): Promise<StreamResponse>;
     generateStream(input: MessageInput, options?: GenerateOptions): Promise<StreamResponse>;
-    getdefaultSubAgent(): SubAgentInterface | undefined;
-    getAgent(name: string): AllSubAgentInterface | undefined;
+    getDefaultSubAgent(): SubAgentInterface | undefined;
+    getSubAgent(name: string): AllSubAgentInterface | undefined;
     getSubAgents(): AllSubAgentInterface[];
-    toFullGraphDefinition(): Promise<FullGraphDefinition>;
+    toFullAgentDefinition(): Promise<FullAgentDefinition>;
 }
 interface BuilderToolConfig {
     name: string;
@@ -549,45 +549,45 @@ declare class SubAgent implements SubAgentInterface {
     private createAgentToolRelation;
 }
 
-declare class AgentGraph implements GraphInterface {
+declare class Agent implements AgentInterface {
     private subAgents;
     private agentMap;
     private defaultSubAgent?;
     private baseURL;
     private tenantId;
     private projectId;
-    private graphId;
-    private graphName;
-    private graphDescription?;
+    private agentId;
+    private agentName;
+    private agentDescription?;
     private initialized;
     private contextConfig?;
     private credentials?;
     private models?;
     private statusUpdateSettings?;
-    private graphPrompt?;
+    private agentPrompt?;
     private stopWhen?;
     private dbClient;
-    constructor(config: GraphConfig);
+    constructor(config: AgentConfig);
     /**
      * Set or update the configuration (tenantId, projectId and apiUrl)
      * This is used by the CLI to inject configuration from inkeep.config.ts
      */
     setConfig(tenantId: string, projectId: string, apiUrl: string): void;
     /**
-     * Convert the AgentGraph to FullGraphDefinition format for the new graph endpoint
+     * Convert the Agent to FullAgentDefinition format for the new agent endpoint
      */
-    toFullGraphDefinition(): Promise<FullGraphDefinition>;
+    toFullAgentDefinition(): Promise<FullAgentDefinition>;
     /**
      * Initialize all tools in all agents (especially IPCTools that need MCP server URLs)
      */
     private initializeAllTools;
     /**
-     * Initialize the graph and all agents in the backend using the new graph endpoint
+     * Initialize the agent and all agents in the backend using the new agent endpoint
      */
     init(): Promise<void>;
     /**
      * Legacy initialization method - kept for backward compatibility
-     * Initialize the graph and all agents in the backend using individual endpoints
+     * Initialize the agent and all agents in the backend using individual endpoints
      */
     initLegacy(): Promise<void>;
     /**
@@ -603,23 +603,23 @@ declare class AgentGraph implements GraphInterface {
      */
     generateStream(input: MessageInput, options?: GenerateOptions): Promise<StreamResponse>;
     /**
-     * Run with a specific agent from the graph
+     * Run with a specific agent from the agent
      */
     runWith(subAgentId: string, input: MessageInput, options?: GenerateOptions): Promise<RunResult>;
     /**
      * Get an agent by name (unified method for all agent types)
      */
-    getAgent(name: string): AllSubAgentInterface | undefined;
+    getSubAgent(name: string): AllSubAgentInterface | undefined;
     /**
-     * Add an agent to the graph
+     * Add an agent to the agent
      */
     addSubAgent(agent: SubAgentInterface): void;
     /**
-     * Remove an agent from the graph
+     * Remove an agent from the agent
      */
     removeSubAgent(id: string): boolean;
     /**
-     * Get all agents in the graph
+     * Get all agents in the agent
      */
     getSubAgents(): AllSubAgentInterface[];
     /**
@@ -629,54 +629,54 @@ declare class AgentGraph implements GraphInterface {
     /**
      * Set the default agent
      */
-    setdefaultSubAgent(agent: SubAgentInterface): void;
+    setDefaultSubAgent(agent: SubAgentInterface): void;
     /**
      * Get the default agent
      */
-    getdefaultSubAgent(): SubAgentInterface | undefined;
+    getDefaultSubAgent(): SubAgentInterface | undefined;
     /**
-     * Get the graph ID
+     * Get the agent ID
      */
     getId(): string;
     getName(): string;
     getDescription(): string | undefined;
     getTenantId(): string;
     /**
-     * Get the graph's model settingsuration
+     * Get the agent's model settingsuration
      */
     getModels(): typeof this.models;
     /**
-     * Set the graph's model settingsuration
+     * Set the agent's model settingsuration
      */
     setModels(models: typeof this.models): void;
     /**
-     * Get the graph's prompt configuration
+     * Get the agent's prompt configuration
      */
-    getGraphPrompt(): string | undefined;
+    getAgentPrompt(): string | undefined;
     /**
-     * Get the graph's stopWhen configuration
+     * Get the agent's stopWhen configuration
      */
-    getStopWhen(): GraphStopWhen;
+    getStopWhen(): AgentStopWhen;
     /**
-     * Get the graph's status updates configuration
+     * Get the agent's status updates configuration
      */
     getStatusUpdateSettings(): StatusUpdateSettings | undefined;
     /**
-     * Get the summarizer model from the graph's model settings
+     * Get the summarizer model from the agent's model settings
      */
     getSummarizerModel(): ModelSettings | undefined;
     /**
-     * Get graph statistics
+     * Get agent statistics
      */
     getStats(): {
         agentCount: number;
         defaultSubAgent: string | null;
         initialized: boolean;
-        graphId: string;
+        agentId: string;
         tenantId: string;
     };
     /**
-     * Validate the graph configuration
+     * Validate the agent configuration
      */
     validate(): {
         valid: boolean;
@@ -696,19 +696,19 @@ declare class AgentGraph implements GraphInterface {
      */
     private getProjectStopWhenDefaults;
     /**
-     * Apply model inheritance hierarchy: Project -> Graph -> Agent
+     * Apply model inheritance hierarchy: Project -> Agent -> Agent
      */
     private applyModelInheritance;
     /**
-     * Apply stopWhen inheritance hierarchy: Project -> Graph -> Agent
+     * Apply stopWhen inheritance hierarchy: Project -> Agent -> Agent
      */
     private applyStopWhenInheritance;
     /**
-     * Propagate graph-level model settings to agents (supporting partial inheritance)
+     * Propagate agent-level model settings to agents (supporting partial inheritance)
      */
     private propagateModelSettingsToAgent;
     /**
-     * Immediately propagate graph-level models to all agents during construction
+     * Immediately propagate agent-level models to all agents during construction
      */
     private propagateImmediateModelSettings;
     /**
@@ -752,7 +752,7 @@ interface ProjectConfig {
     };
     stopWhen?: StopWhen;
     sandboxConfig?: SandboxConfig;
-    graphs?: () => AgentGraph[];
+    agents?: () => Agent[];
     tools?: () => Tool[];
     dataComponents?: () => DataComponent[];
     artifactComponents?: () => ArtifactComponent[];
@@ -770,13 +770,13 @@ interface ProjectInterface {
     getTenantId(): string;
     getModels(): ProjectConfig['models'];
     getStopWhen(): ProjectConfig['stopWhen'];
-    getGraphs(): AgentGraph[];
-    addGraph(graph: AgentGraph): void;
-    removeGraph(id: string): boolean;
+    getAgents(): Agent[];
+    addAgent(agent: Agent): void;
+    removeAgent(id: string): boolean;
     getStats(): {
         projectId: string;
         tenantId: string;
-        graphCount: number;
+        agentCount: number;
         initialized: boolean;
     };
     validate(): {
@@ -787,8 +787,8 @@ interface ProjectInterface {
 /**
  * Project class for managing agent projects
  *
- * Projects are the top-level organizational unit that contains graphs, agents, and shared configurations.
- * They provide model inheritance and execution limits that cascade down to graphs and agents.
+ * Projects are the top-level organizational unit that contains agent, agents, and shared configurations.
+ * They provide model inheritance and execution limits that cascade down to agent and agents.
  *
  * @example
  * ```typescript
@@ -821,8 +821,8 @@ declare class Project implements ProjectInterface {
     private models?;
     private stopWhen?;
     private sandboxConfig?;
-    private graphs;
-    private graphMap;
+    private agents;
+    private agentMap;
     private credentialReferences?;
     private projectTools;
     private projectDataComponents;
@@ -882,33 +882,33 @@ declare class Project implements ProjectInterface {
         usage: Record<string, Array<{
             type: string;
             id: string;
-            graphId?: string;
+            agentId?: string;
         }>>;
     }>;
     getFullDefinition(): Promise<FullProjectDefinition>;
     /**
-     * Get all graphs in the project
+     * Get all agent in the project
      */
-    getGraphs(): AgentGraph[];
+    getAgents(): Agent[];
     /**
-     * Get a graph by ID
+     * Get an agent by ID
      */
-    getGraph(id: string): AgentGraph | undefined;
+    getAgent(id: string): Agent | undefined;
     /**
-     * Add a graph to the project
+     * Add an agent to the project
      */
-    addGraph(graph: AgentGraph): void;
+    addAgent(agent: Agent): void;
     /**
-     * Remove a graph from the project
+     * Remove an agent from the project
      */
-    removeGraph(id: string): boolean;
+    removeAgent(id: string): boolean;
     /**
      * Get project statistics
      */
     getStats(): {
         projectId: string;
         tenantId: string;
-        graphCount: number;
+        agentCount: number;
         initialized: boolean;
     };
     /**
@@ -925,14 +925,14 @@ declare class Project implements ProjectInterface {
 }
 
 /**
- * Helper function to create graphs - OpenAI style
+ * Helper function to create agent - OpenAI style
  */
-declare function agentGraph(config: GraphConfig): AgentGraph;
+declare function agent(config: AgentConfig): Agent;
 /**
  * Helper function to create projects - OpenAI style
  *
- * Projects are the top-level organizational unit that contains graphs, agents, and shared configurations.
- * They provide model inheritance and execution limits that cascade down to graphs and agents.
+ * Projects are the top-level organizational unit that contains agent, agents, and shared configurations.
+ * They provide model inheritance and execution limits that cascade down to agent and agents.
  *
  * @param config - Project configuration
  * @returns A new Project instance
@@ -951,11 +951,11 @@ declare function agentGraph(config: GraphConfig): AgentGraph;
  *     transferCountIs: 10,
  *     stepCountIs: 50
  *   },
- *   graphs: () => [
- *     agentGraph({
- *       id: 'support-graph',
- *       name: 'Support Graph',
- *       // ... graph config
+ *   agent: () => [
+ *     agent({
+ *       id: 'support-agent',
+ *       name: 'Support Agent',
+ *       // ... agent config
  *     })
  *   ]
  * });
@@ -1243,39 +1243,39 @@ declare function deleteFullProjectViaAPI(tenantId: string, apiUrl: string, proje
 
 declare class Runner {
     /**
-     * Run a graph until completion, handling transfers and tool calls
+     * Run an agent until completion, handling transfers and tool calls
      * Similar to OpenAI's Runner.run() pattern
-     * NOTE: This now requires a graph instead of an agent
+     * NOTE: This now requires an agent instead of an agent
      */
-    static run(graph: GraphInterface, messages: MessageInput, options?: GenerateOptions): Promise<RunResult>;
+    static run(agent: AgentInterface, messages: MessageInput, options?: GenerateOptions): Promise<RunResult>;
     /**
-     * Stream a graph's response
+     * Stream an agent's response
      */
-    static stream(graph: GraphInterface, messages: MessageInput, options?: GenerateOptions): Promise<StreamResponse>;
+    static stream(agent: AgentInterface, messages: MessageInput, options?: GenerateOptions): Promise<StreamResponse>;
     /**
-     * Execute multiple graphs in parallel and return the first successful result
+     * Execute multiple agent in parallel and return the first successful result
      */
-    static raceGraphs(graphs: GraphInterface[], messages: MessageInput, options?: GenerateOptions): Promise<RunResult>;
+    static raceAgents(agent: AgentInterface[], messages: MessageInput, options?: GenerateOptions): Promise<RunResult>;
     private static normalizeToMessageHistory;
     /**
-     * Validate graph configuration before running
+     * Validate agent configuration before running
      */
-    static validateGraph(graph: GraphInterface): {
+    static validateAgent(agent: AgentInterface): {
         valid: boolean;
         errors: string[];
     };
     /**
-     * Get execution statistics for a graph
+     * Get execution statistics for an agent
      */
-    static getExecutionStats(graph: GraphInterface, messages: MessageInput, options?: GenerateOptions): Promise<{
+    static getExecutionStats(agent: AgentInterface, messages: MessageInput, options?: GenerateOptions): Promise<{
         estimatedTurns: number;
         estimatedTokens: number;
-        agentCount: number;
+        subAgentCount: number;
         defaultSubAgent: string | undefined;
     }>;
 }
 declare const run: typeof Runner.run;
 declare const stream: typeof Runner.stream;
-declare const raceGraphs: typeof Runner.raceGraphs;
+declare const raceAgents: typeof Runner.raceAgents;
 
-export { SubAgent as Agent, AgentError, type AgentResponse, type AgentTool, type AllSubAgentInterface, ArtifactComponent, type ArtifactComponentInterface, type ArtifactComponentWithZodProps, type AssistantMessage, type BuilderAgentConfig, type BuilderRelationConfig, type BuilderToolConfig, type CredentialReference, DataComponent, type DataComponentInterface, type DataComponentWithZodProps, ExternalAgent, type ExternalAgentInterface, type ExtractCredentialIds, type FetchDefinitionConfig, FunctionTool, type GenerateOptions, type GraphConfig, type GraphInterface, type MCPToolConfig, MaxTurnsExceededError, type Message, type MessageInput, Project, type RequestSchemaConfig, type RequestSchemaDefinition, type RunResult, Runner, type ServerConfig, type StreamEvent, type StreamResponse, type SubAgentCanUseType, type SubAgentConfig, type SubAgentInterface, type SystemMessage, Tool, type ToolCall, type ToolConfig, ToolExecutionError, type ToolMessage, type ToolResult, type TransferConfig, TransferError, type UnionCredentialIds, type UserMessage, subAgent as agent, agentGraph, agentMcp, artifactComponent, createEnvironmentSettings, createFullProjectViaAPI, credential, credentialRef, dataComponent, deleteFullProjectViaAPI, externalAgent, externalAgents, functionTool, getFullProjectViaAPI, isCredentialReference, mcpServer, mcpTool, project, raceGraphs, registerEnvironmentSettings, run, stream, transfer, updateFullProjectViaAPI };
+export { type AgentConfig, AgentError, type AgentInterface, type AgentResponse, type AgentTool, type AllSubAgentInterface, ArtifactComponent, type ArtifactComponentInterface, type ArtifactComponentWithZodProps, type AssistantMessage, type BuilderAgentConfig, type BuilderRelationConfig, type BuilderToolConfig, type CredentialReference, DataComponent, type DataComponentInterface, type DataComponentWithZodProps, ExternalAgent, type ExternalAgentInterface, type ExtractCredentialIds, type FetchDefinitionConfig, FunctionTool, type GenerateOptions, type MCPToolConfig, MaxTurnsExceededError, type Message, type MessageInput, Project, type RequestSchemaConfig, type RequestSchemaDefinition, type RunResult, Runner, type ServerConfig, type StreamEvent, type StreamResponse, SubAgent, type SubAgentCanUseType, type SubAgentConfig, type SubAgentInterface, type SystemMessage, Tool, type ToolCall, type ToolConfig, ToolExecutionError, type ToolMessage, type ToolResult, type TransferConfig, TransferError, type UnionCredentialIds, type UserMessage, agent, agentMcp, artifactComponent, createEnvironmentSettings, createFullProjectViaAPI, credential, credentialRef, dataComponent, deleteFullProjectViaAPI, externalAgent, externalAgents, functionTool, getFullProjectViaAPI, isCredentialReference, mcpServer, mcpTool, project, raceAgents, registerEnvironmentSettings, run, stream, subAgent, transfer, updateFullProjectViaAPI };