@inkeep/agents-sdk 0.0.0-dev-20250910233133 → 0.0.0-dev-20250910233441

package/dist/index.d.ts

@@ -1,11 +1,855 @@
-export { Agent } from "./agent";
-export { ArtifactComponent } from "./artifact-component";
-export { agent, artifactComponent, credential, dataComponent, mcpServer, mcpTool, tool, transfer, } from "./builders";
-export { DataComponent } from "./data-component";
-export { createEnvironmentSettings, getAllEnvironmentSettingKeys, registerEnvironmentSettings, } from "./environment-settings";
-export { ExternalAgent, externalAgent, externalAgents, } from "./externalAgent";
-export { AgentGraph, agentGraph, generateGraph } from "./graph";
-export { Runner, raceGraphs, run, stream } from "./runner";
-export { Tool } from "./tool";
-export type * from "./types";
-//# sourceMappingURL=index.d.ts.map
+import { CredentialReferenceSelect, AgentApiInsert, DataComponentApiInsert, ArtifactComponentApiInsert, AgentConversationHistoryConfig, CredentialReferenceApiInsert, ToolInsert, McpTransportConfig, ArtifactComponentInsert, DataComponentInsert, MCPToolConfig as MCPToolConfig$1 } from '@inkeep/agents-core';
+import { z } from 'zod';
+
+type ExternalAgentConfig = {
+    type?: "external";
+    tenantId?: string;
+    id: string;
+    name: string;
+    description: string;
+    baseUrl: string;
+    credentialReference?: CredentialReferenceSelect;
+    headers?: Record<string, string>;
+};
+declare class ExternalAgent implements ExternalAgentInterface {
+    config: ExternalAgentConfig;
+    readonly type: "external";
+    private initialized;
+    private tenantId;
+    private baseURL;
+    constructor(config: ExternalAgentConfig);
+    /**
+     * Initialize the external agent by upserting it in the database
+     */
+    init(): Promise<void>;
+    getId(): string;
+    private upsertExternalAgent;
+    /**
+     * Get the external agent configuration
+     */
+    getConfig(): ExternalAgentConfig;
+    /**
+     * Get the external agent name
+     */
+    getName(): string;
+    /**
+     * Get the external agent base URL
+     */
+    getBaseUrl(): string;
+    /**
+     * Get the tenant ID
+     */
+    getTenantId(): string;
+    getDescription(): string;
+    getCredentialReferenceId(): string | undefined;
+    getHeaders(): Record<string, string> | undefined;
+}
+/**
+ * Factory function to create external agents - follows the same pattern as agent()
+ */
+declare function externalAgent(config: ExternalAgentConfig): ExternalAgent;
+/**
+ * Helper function to create multiple external agents
+ */
+declare function externalAgents(configs: Record<string, ExternalAgentConfig>): Record<string, ExternalAgent>;
+
+interface UserMessage {
+    role: "user";
+    content: string;
+}
+interface AssistantMessage {
+    role: "assistant";
+    content: string;
+    toolCalls?: ToolCall[];
+}
+interface ToolMessage {
+    role: "tool";
+    content: string;
+    toolCallId: string;
+}
+interface SystemMessage {
+    role: "system";
+    content: string;
+}
+type Message = UserMessage | AssistantMessage | ToolMessage | SystemMessage;
+type MessageInput = string | string[] | Message | Message[];
+interface ToolCall {
+    id: string;
+    type: "function";
+    function: {
+        name: string;
+        arguments: string;
+    };
+}
+interface ToolResult {
+    id: string;
+    result: any;
+    error?: string;
+}
+type AllAgentInterface = AgentInterface | ExternalAgentInterface;
+interface AgentConfig extends Omit<AgentApiInsert, "projectId"> {
+    type?: "internal";
+    tools?: () => any[];
+    canTransferTo?: () => AgentInterface[];
+    canDelegateTo?: () => AllAgentInterface[];
+    tenantId?: string;
+    projectId?: string;
+    models?: {
+        base?: ModelSettings;
+        structuredOutput?: ModelSettings;
+        summarizer?: ModelSettings;
+    };
+    stopWhen?: {
+        stepCountIs?: number;
+    };
+    memory?: {
+        type: "conversation" | "episodic" | "short_term";
+        capacity?: number;
+    };
+    dataComponents?: () => DataComponentApiInsert[];
+    artifactComponents?: () => ArtifactComponentApiInsert[];
+    conversationHistoryConfig?: AgentConversationHistoryConfig;
+}
+interface ModelSettings {
+    model?: string;
+    providerOptions?: Record<string, Record<string, unknown>>;
+}
+declare const ModelSettingsSchema: z.ZodObject<{
+    model: z.ZodOptional<z.ZodString>;
+    providerOptions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+}, z.core.$strip>;
+interface ToolConfig extends ToolInsert {
+    execute: (params: any) => Promise<any>;
+    parameters?: Record<string, any>;
+    schema?: z.ZodJSONSchema;
+}
+interface ServerConfig {
+    type: string;
+    version?: string;
+}
+interface MCPToolConfig {
+    id: string;
+    name: string;
+    tenantId?: string;
+    description?: string;
+    credential?: CredentialReferenceApiInsert;
+    server?: ServerConfig;
+    serverUrl: string;
+    toolName?: string;
+    activeTools?: string[];
+    headers?: Record<string, string>;
+    mcpType?: "nango" | "generic";
+    transport?: McpTransportConfig;
+    imageUrl?: string;
+}
+interface FetchDefinitionConfig {
+    id: string;
+    name?: string;
+    trigger: "initialization" | "invocation";
+    url: string;
+    method?: string;
+    headers?: Record<string, string>;
+    body?: Record<string, unknown>;
+    transform?: string;
+    responseSchema?: z.ZodSchema<any>;
+    defaultValue?: unknown;
+    timeout?: number;
+    credential?: CredentialReferenceApiInsert;
+}
+interface RequestSchemaDefinition {
+    body?: z.ZodSchema<any>;
+    headers?: z.ZodSchema<any>;
+    query?: z.ZodSchema<any>;
+    params?: z.ZodSchema<any>;
+}
+interface RequestSchemaConfig {
+    schemas: RequestSchemaDefinition;
+    optional?: ("body" | "headers" | "query" | "params")[];
+}
+interface TransferConfig {
+    agent: AgentInterface;
+    description?: string;
+    condition?: (context: any) => boolean;
+}
+interface GenerateOptions {
+    maxTurns?: number;
+    maxSteps?: number;
+    temperature?: number;
+    toolChoice?: "auto" | "none" | string;
+    resourceId?: string;
+    conversationId?: string;
+    stream?: boolean;
+    customBodyParams?: Record<string, unknown>;
+}
+interface AgentResponse {
+    id?: string;
+    text: string;
+    toolCalls?: ToolCall[];
+    transfer?: TransferConfig;
+    finishReason: "completed" | "tool_calls" | "transfer" | "max_turns" | "error";
+    usage?: {
+        inputTokens: number;
+        outputTokens: number;
+        totalTokens?: number;
+    };
+    metadata?: Record<string, any>;
+}
+interface StreamResponse {
+    textStream?: AsyncGenerator<string>;
+    eventStream?: AsyncGenerator<StreamEvent>;
+}
+interface StreamEvent {
+    type: "text" | "tool_call" | "transfer" | "error" | "done";
+    data: any;
+    timestamp: Date;
+}
+interface RunResult {
+    finalOutput: string;
+    agent: AgentInterface;
+    turnCount: number;
+    usage?: {
+        inputTokens: number;
+        outputTokens: number;
+        totalTokens?: number;
+    };
+    metadata?: {
+        toolCalls: ToolCall[];
+        transfers: TransferConfig[];
+    };
+}
+interface StatusComponent {
+    id: string;
+    name: string;
+    type: string;
+    description?: string;
+    schema: {
+        type: "object";
+        properties: Record<string, any>;
+        required?: string[];
+    };
+}
+interface StatusUpdateSettings {
+    enabled?: boolean;
+    numEvents?: number;
+    timeInSeconds?: number;
+    model?: string;
+    statusComponents?: StatusComponent[];
+    prompt?: string;
+}
+interface GraphConfig {
+    id: string;
+    name?: string;
+    description?: string;
+    defaultAgent?: AgentInterface;
+    agents?: () => AllAgentInterface[];
+    tenantId?: string;
+    contextConfig?: any;
+    credentials?: () => CredentialReferenceApiInsert[];
+    stopWhen?: {
+        transferCountIs?: number;
+    };
+    graphPrompt?: string;
+    models?: {
+        base?: ModelSettings;
+        structuredOutput?: ModelSettings;
+        summarizer?: ModelSettings;
+    };
+    statusUpdates?: StatusUpdateSettings;
+}
+declare class AgentError extends Error {
+    code?: string | undefined;
+    details?: any | undefined;
+    constructor(message: string, code?: string | undefined, details?: any | undefined);
+}
+declare class MaxTurnsExceededError extends AgentError {
+    constructor(maxTurns: number);
+}
+declare class ToolExecutionError extends AgentError {
+    constructor(toolName: string, originalError: Error);
+}
+declare class TransferError extends AgentError {
+    constructor(sourceAgent: string, targetAgent: string, reason: string);
+}
+interface AgentInterface {
+    config: AgentConfig;
+    type: "internal";
+    init(): Promise<void>;
+    getId(): string;
+    getName(): string;
+    getInstructions(): string;
+    getTools(): Record<string, any>;
+    getTransfers(): AgentInterface[];
+    getDelegates(): AllAgentInterface[];
+    getDataComponents(): DataComponentApiInsert[];
+    getArtifactComponents(): ArtifactComponentApiInsert[];
+    addTool(name: string, tool: any): void;
+    addTransfer(...agents: AgentInterface[]): void;
+    addDelegate(...agents: AgentInterface[]): void;
+}
+interface ExternalAgentInterface {
+    config: ExternalAgentConfig;
+    type: "external";
+    init(): Promise<void>;
+    getId(): string;
+    getName(): string;
+    getDescription(): string;
+    getBaseUrl(): string;
+    getCredentialReferenceId(): string | undefined;
+    getHeaders(): Record<string, string> | undefined;
+}
+interface GraphInterface {
+    init(): Promise<void>;
+    setConfig(tenantId: string, projectId: string, apiUrl: string): void;
+    getId(): string;
+    getName(): string;
+    getDescription(): string | undefined;
+    getTenantId(): string;
+    generate(input: MessageInput, options?: GenerateOptions): Promise<string>;
+    stream(input: MessageInput, options?: GenerateOptions): Promise<StreamResponse>;
+    generateStream(input: MessageInput, options?: GenerateOptions): Promise<StreamResponse>;
+    getDefaultAgent(): AgentInterface | undefined;
+    getAgent(name: string): AllAgentInterface | undefined;
+    getAgents(): AllAgentInterface[];
+}
+interface BuilderToolConfig {
+    name: string;
+    description: string;
+    config: {
+        type: "mcp";
+        mcp: {
+            server: {
+                url: string;
+            };
+        };
+    };
+    parameters?: Record<string, any>;
+}
+interface BuilderRelationConfig {
+    targetAgent: string;
+    relationType: "transfer" | "delegate";
+}
+interface BuilderAgentConfig {
+    name: string;
+    description: string;
+    instructions: string;
+    tools: BuilderToolConfig[];
+    relations?: BuilderRelationConfig[];
+}
+
+declare class Agent implements AgentInterface {
+    config: AgentConfig;
+    readonly type: "internal";
+    private baseURL;
+    private tenantId;
+    private projectId;
+    private initialized;
+    constructor(config: AgentConfig);
+    getId(): string;
+    getName(): string;
+    getInstructions(): string;
+    getTools(): Record<string, unknown>;
+    getModels(): typeof this$1.config.models;
+    setModels(models: typeof this$1.config.models): void;
+    getTransfers(): AgentInterface[];
+    getDelegates(): AllAgentInterface[];
+    getDataComponents(): DataComponentApiInsert[];
+    getArtifactComponents(): ArtifactComponentApiInsert[];
+    addTool(_name: string, tool: unknown): void;
+    addTransfer(...agents: AgentInterface[]): void;
+    addDelegate(...agents: AllAgentInterface[]): void;
+    init(): Promise<void>;
+    private upsertAgent;
+    private saveToolsAndRelations;
+    private saveDataComponents;
+    private saveArtifactComponents;
+    private loadDataComponents;
+    private loadArtifactComponents;
+    private createTool;
+    private createDataComponent;
+    private createArtifactComponent;
+    private createAgentDataComponentRelation;
+    private createAgentArtifactComponentRelation;
+    private createAgentToolRelation;
+}
+
+interface ArtifactComponentInterface {
+    config: Omit<ArtifactComponentInsert, "id">;
+    init(): Promise<void>;
+    getId(): ArtifactComponentInsert["id"];
+    getName(): ArtifactComponentInsert["name"];
+    getDescription(): ArtifactComponentInsert["description"];
+    getSummaryProps(): ArtifactComponentInsert["summaryProps"];
+    getFullProps(): ArtifactComponentInsert["fullProps"];
+}
+declare class ArtifactComponent implements ArtifactComponentInterface {
+    config: ArtifactComponentInsert;
+    private baseURL;
+    private tenantId;
+    private projectId;
+    private initialized;
+    private id;
+    constructor(config: Omit<ArtifactComponentInsert, "id">);
+    getId(): string;
+    getName(): string;
+    getDescription(): string;
+    getSummaryProps(): ArtifactComponentInsert["summaryProps"];
+    getFullProps(): ArtifactComponentInsert["fullProps"];
+    init(): Promise<void>;
+    private upsertArtifactComponent;
+}
+
+interface DataComponentInterface {
+    config: Omit<DataComponentInsert, "id">;
+    init(): Promise<void>;
+    getId(): DataComponentInsert["id"];
+    getName(): DataComponentInsert["name"];
+    getDescription(): DataComponentInsert["description"];
+    getProps(): DataComponentInsert["props"];
+}
+declare class DataComponent implements DataComponentInterface {
+    config: DataComponentInsert;
+    private baseURL;
+    private tenantId;
+    private projectId;
+    private initialized;
+    private id;
+    constructor(config: Omit<DataComponentInsert, "id">);
+    getId(): string;
+    getName(): string;
+    getDescription(): string;
+    getProps(): DataComponentInsert["props"];
+    init(): Promise<void>;
+    private upsertDataComponent;
+}
+
+interface ToolInterface {
+    config: MCPToolConfig$1;
+    init(): Promise<void>;
+    getId(): string;
+    getName(): string;
+    getDescription(): string;
+    getServerUrl(): string;
+    getActiveTools(): string[] | undefined;
+    getCredentialReferenceId(): string | null | undefined;
+}
+declare class Tool implements ToolInterface {
+    config: MCPToolConfig$1;
+    private baseURL;
+    private tenantId;
+    private initialized;
+    constructor(config: MCPToolConfig$1);
+    getId(): string;
+    getName(): string;
+    getDescription(): string;
+    getServerUrl(): string;
+    getActiveTools(): string[] | undefined;
+    getCredentialReferenceId(): string | null | undefined;
+    init(options?: {
+        skipDatabaseRegistration?: boolean;
+    }): Promise<void>;
+    private upsertTool;
+}
+
+/**
+ * Creates a new agent with stable ID enforcement.
+ *
+ * @param config - Agent configuration including required stable ID
+ * @returns A new Agent instance
+ * @throws Error if config.id is not provided (stable IDs are required)
+ *
+ * @example
+ * ```typescript
+ * const myAgent = agent({
+ *   id: 'customer-support-agent',
+ *   name: 'Customer Support',
+ *   prompt: 'Help customers with their questions'
+ * });
+ * ```
+ */
+declare function agent(config: AgentConfig): Agent;
+declare function credential(config: CredentialReferenceApiInsert): {
+    type: string;
+    id: string;
+    credentialStoreId: string;
+    retrievalParams?: Record<string, unknown> | null | undefined;
+};
+/**
+ * Creates a tool with automatic ID generation (unlike agents which require explicit IDs).
+ *
+ * Tools automatically generate IDs from their name, whereas agents require stable IDs
+ * to be explicitly provided for consistency across deployments.
+ *
+ * @param config - Tool configuration with auto-generated ID
+ * @returns A Tool instance with auto-generated ID based on name
+ *
+ * @example
+ * ```typescript
+ * const searchTool = tool({
+ *   name: 'Search Database',
+ *   description: 'Search the product database',
+ *   execute: async (params) => { ... }
+ * });
+ * // ID will be auto-generated as 'search-database'
+ * ```
+ */
+declare function tool(config: {
+    name: string;
+    description: string;
+    execute: (params: any) => Promise<any>;
+    parameters?: Record<string, any>;
+    schema?: z.ZodJSONSchema;
+}): {
+    id: string;
+    name: string;
+    description: string;
+    execute: (params: any) => Promise<any>;
+    parameters: Record<string, any> | undefined;
+    schema: unknown;
+    type: "function";
+};
+/**
+ * Creates an MCP (Model Context Protocol) server for tool functionality.
+ *
+ * This unified builder replaces tool(), mcpTool(), ipcTool(), and hostedTool().
+ * All tools are MCP servers - either local (with execute function) or remote (with URL).
+ *
+ * @param config - MCP server configuration
+ * @returns An MCP server instance that can be used as a tool in agents
+ *
+ * @example
+ * ```typescript
+ * // Local MCP server with execute function (auto-wrapped via IPC)
+ * const searchServer = mcpServer({
+ *   name: 'search',
+ *   description: 'Search the database',
+ *   execute: async (params) => {
+ *     // Implementation
+ *     return results;
+ *   }
+ * });
+ *
+ * // Remote MCP server
+ * const apiServer = mcpServer({
+ *   name: 'external_api',
+ *   description: 'External API service',
+ *   serverUrl: 'https://api.example.com/mcp'
+ * });
+ * ```
+ */
+declare function mcpServer(config: {
+    name: string;
+    description: string;
+    deployment?: "local" | "remote";
+    execute?: (params: any) => Promise<any>;
+    port?: number;
+    serverUrl?: string;
+    id?: string;
+    parameters?: Record<string, z.ZodJSONSchema>;
+    credential?: CredentialReferenceApiInsert;
+    tenantId?: string;
+    transport?: "ipc" | "http" | "sse";
+    activeTools?: string[];
+    headers?: Record<string, string>;
+}): Tool;
+declare function mcpTool(config: MCPToolConfig$1): Tool;
+declare function transfer(targetAgent: Agent, description?: string, condition?: (context: unknown) => boolean): TransferConfig;
+/**
+ * Creates an artifact component with automatic ID generation.
+ *
+ * @param config - Artifact component configuration
+ * @returns An ArtifactComponent instance with auto-generated ID
+ *
+ * @example
+ * ```typescript
+ * const productCard = artifactComponent({
+ *   name: 'Product Card',
+ *   description: 'Display product information',
+ *   summaryProps: { title: 'Product', price: '$0' },
+ *   fullProps: { title: 'Product', price: '$0', description: '...' }
+ * });
+ * ```
+ */
+declare function artifactComponent(config: {
+    name: string;
+    description: string;
+    summaryProps: Record<string, any>;
+    fullProps: Record<string, any>;
+    tenantId?: string;
+    projectId?: string;
+}): ArtifactComponent;
+/**
+ * Creates a data component with automatic ID generation.
+ *
+ * @param config - Data component configuration
+ * @returns A DataComponent instance with auto-generated ID
+ *
+ * @example
+ * ```typescript
+ * const userProfile = dataComponent({
+ *   name: 'User Profile',
+ *   description: 'User profile data',
+ *   props: { userId: '123', name: 'John Doe' }
+ * });
+ * ```
+ */
+declare function dataComponent(config: {
+    name: string;
+    description: string;
+    props: Record<string, any>;
+    tenantId?: string;
+    projectId?: string;
+}): DataComponent;
+
+interface EnvironmentSettingsConfig {
+    credentials?: {
+        [settingId: string]: CredentialReferenceApiInsert;
+    };
+}
+/**
+ * Create a setting helper with TypeScript autocomplete
+ */
+declare function createEnvironmentSettings<T extends Record<string, EnvironmentSettingsConfig>>(environments: T): {
+    getEnvironmentSetting: (key: keyof NonNullable<T[keyof T]["credentials"]>) => Promise<CredentialReferenceApiInsert>;
+};
+/**
+ * Create type-safe environment configurations
+ */
+declare function registerEnvironmentSettings<T extends EnvironmentSettingsConfig>(config: T): T;
+
+declare class AgentGraph implements GraphInterface {
+    private agents;
+    private agentMap;
+    private defaultAgent?;
+    private baseURL;
+    private tenantId;
+    private projectId;
+    private graphId;
+    private graphName;
+    private graphDescription?;
+    private initialized;
+    private contextConfig?;
+    private credentials?;
+    private models?;
+    private statusUpdateSettings?;
+    private graphPrompt?;
+    private stopWhen?;
+    private dbClient;
+    constructor(config: GraphConfig);
+    /**
+     * 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
+     */
+    private toFullGraphDefinition;
+    /**
+     * 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
+     */
+    init(): Promise<void>;
+    /**
+     * Legacy initialization method - kept for backward compatibility
+     * Initialize the graph and all agents in the backend using individual endpoints
+     */
+    initLegacy(): Promise<void>;
+    /**
+     * Generate a response using the default agent
+     */
+    generate(input: MessageInput, options?: GenerateOptions): Promise<string>;
+    /**
+     * Stream a response using the default agent
+     */
+    stream(input: MessageInput, options?: GenerateOptions): Promise<StreamResponse>;
+    /**
+     * Alias for stream() method for consistency with naming patterns
+     */
+    generateStream(input: MessageInput, options?: GenerateOptions): Promise<StreamResponse>;
+    /**
+     * Run with a specific agent from the graph
+     */
+    runWith(agentId: string, input: MessageInput, options?: GenerateOptions): Promise<RunResult>;
+    /**
+     * Get an agent by name (unified method for all agent types)
+     */
+    getAgent(name: string): AllAgentInterface | undefined;
+    /**
+     * Add an agent to the graph
+     */
+    addAgent(agent: AgentInterface): void;
+    /**
+     * Remove an agent from the graph
+     */
+    removeAgent(id: string): boolean;
+    /**
+     * Get all agents in the graph
+     */
+    getAgents(): AllAgentInterface[];
+    /**
+     * Get all agent ids (unified method for all agent types)
+     */
+    getAgentIds(): string[];
+    /**
+     * Set the default agent
+     */
+    setDefaultAgent(agent: AgentInterface): void;
+    /**
+     * Get the default agent
+     */
+    getDefaultAgent(): AgentInterface | undefined;
+    /**
+     * Get the graph ID
+     */
+    getId(): string;
+    getName(): string;
+    getDescription(): string | undefined;
+    getTenantId(): string;
+    /**
+     * Get the graph's model settingsuration
+     */
+    getModels(): typeof this.models;
+    /**
+     * Set the graph's model settingsuration
+     */
+    setModels(models: typeof this.models): void;
+    /**
+     * Get the graph's prompt configuration
+     */
+    getGraphPrompt(): string | undefined;
+    /**
+     * Get the graph's stopWhen configuration
+     */
+    getStopWhen(): {
+        transferCountIs?: number;
+    };
+    /**
+     * Get the graph's status updates configuration
+     */
+    getStatusUpdateSettings(): StatusUpdateSettings | undefined;
+    /**
+     * Get the summarizer model from the graph's model settings
+     */
+    getSummarizerModel(): ModelSettings | undefined;
+    /**
+     * Get graph statistics
+     */
+    getStats(): {
+        agentCount: number;
+        defaultAgent: string | null;
+        initialized: boolean;
+        graphId: string;
+        tenantId: string;
+    };
+    /**
+     * Validate the graph configuration
+     */
+    validate(): {
+        valid: boolean;
+        errors: string[];
+    };
+    private _init;
+    /**
+     * Type guard to check if an agent is an internal AgentInterface
+     */
+    isInternalAgent(agent: AllAgentInterface): agent is AgentInterface;
+    /**
+     * Get project-level model settingsuration defaults
+     */
+    private getProjectModelDefaults;
+    /**
+     * Get project-level stopWhen configuration defaults
+     */
+    private getProjectStopWhenDefaults;
+    /**
+     * Apply model inheritance hierarchy: Project -> Graph -> Agent
+     */
+    private applyModelInheritance;
+    /**
+     * Apply stopWhen inheritance hierarchy: Project -> Graph -> Agent
+     */
+    private applyStopWhenInheritance;
+    /**
+     * Propagate graph-level model settings to agents (supporting partial inheritance)
+     */
+    private propagateModelSettingsToAgent;
+    /**
+     * Immediately propagate graph-level models to all agents during construction
+     */
+    private propagateImmediateModelSettings;
+    /**
+     * Type guard to check if an agent is an external AgentInterface
+     */
+    isExternalAgent(agent: AllAgentInterface): agent is ExternalAgentInterface;
+    /**
+     * Execute agent using the backend system instead of local runner
+     */
+    private executeWithBackend;
+    /**
+     * Parse streaming response in SSE format
+     */
+    private parseStreamingResponse;
+    /**
+     * Normalize input messages to the expected format
+     */
+    private normalizeMessages;
+    private saveToDatabase;
+    private saveRelations;
+    private createAgentRelations;
+    private createInternalAgentRelation;
+    private createExternalAgentRelation;
+    /**
+     * Create external agents in the database
+     */
+    private createExternalAgents;
+}
+/**
+ * Helper function to create graphs - OpenAI style
+ */
+declare function agentGraph(config: GraphConfig): AgentGraph;
+/**
+ * Factory function to create graph from configuration file
+ */
+declare function generateGraph(configPath: string): Promise<AgentGraph>;
+
+declare class Runner {
+    /**
+     * Run a graph until completion, handling transfers and tool calls
+     * Similar to OpenAI's Runner.run() pattern
+     * NOTE: This now requires a graph instead of an agent
+     */
+    static run(graph: GraphInterface, messages: MessageInput, options?: GenerateOptions): Promise<RunResult>;
+    /**
+     * Stream a graph's response
+     */
+    static stream(graph: GraphInterface, messages: MessageInput, options?: GenerateOptions): Promise<StreamResponse>;
+    /**
+     * Execute multiple graphs in parallel and return the first successful result
+     */
+    static raceGraphs(graphs: GraphInterface[], messages: MessageInput, options?: GenerateOptions): Promise<RunResult>;
+    private static normalizeToMessageHistory;
+    /**
+     * Validate graph configuration before running
+     */
+    static validateGraph(graph: GraphInterface): {
+        valid: boolean;
+        errors: string[];
+    };
+    /**
+     * Get execution statistics for a graph
+     */
+    static getExecutionStats(graph: GraphInterface, messages: MessageInput, options?: GenerateOptions): Promise<{
+        estimatedTurns: number;
+        estimatedTokens: number;
+        agentCount: number;
+        defaultAgent: string | undefined;
+    }>;
+}
+declare const run: typeof Runner.run;
+declare const stream: typeof Runner.stream;
+declare const raceGraphs: typeof Runner.raceGraphs;
+
+export { Agent, type AgentConfig, AgentError, AgentGraph, type AgentInterface, type AgentResponse, type AllAgentInterface, ArtifactComponent, type AssistantMessage, type BuilderAgentConfig, type BuilderRelationConfig, type BuilderToolConfig, DataComponent, ExternalAgent, type ExternalAgentInterface, type FetchDefinitionConfig, type GenerateOptions, type GraphConfig, type GraphInterface, type MCPToolConfig, MaxTurnsExceededError, type Message, type MessageInput, type ModelSettings, ModelSettingsSchema, type RequestSchemaConfig, type RequestSchemaDefinition, type RunResult, Runner, type ServerConfig, type StatusComponent, type StatusUpdateSettings, type StreamEvent, type StreamResponse, type SystemMessage, Tool, type ToolCall, type ToolConfig, ToolExecutionError, type ToolMessage, type ToolResult, type TransferConfig, TransferError, type UserMessage, agent, agentGraph, artifactComponent, createEnvironmentSettings, credential, dataComponent, externalAgent, externalAgents, generateGraph, mcpServer, mcpTool, raceGraphs, registerEnvironmentSettings, run, stream, tool, transfer };