@inkeep/agents-sdk 0.0.0-chat-to-edit-20251119071712

package/dist/index.d.cts

@@ -0,0 +1,1457 @@
+import { ArtifactComponentInsert, MCPToolConfig as MCPToolConfig$1, DataComponentApiInsert, ArtifactComponentApiInsert, McpToolSelection, ToolPolicy, CredentialReferenceApiInsert, DataComponentInsert, FunctionToolConfig, SubAgentApiInsert, FullAgentDefinition, AgentConversationHistoryConfig, AgentStopWhen, ModelSettings, StatusUpdateSettings, ToolInsert, McpTransportConfig, StopWhen, FullProjectDefinition, StatusComponent as StatusComponent$1 } from '@inkeep/agents-core';
+export { ANTHROPIC_MODELS, FunctionToolConfig, GOOGLE_MODELS, ModelSettings, OPENAI_MODELS } 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>;
+    getId(): string;
+    getName(): string;
+    getDescription(): string;
+    getServerUrl(): string;
+    getActiveTools(): string[] | undefined;
+    getCredentialReferenceId(): string | null | undefined;
+    with(config: AgentMcpConfigInput): AgentMcpConfig;
+}
+declare class Tool implements ToolInterface {
+    config: MCPToolConfig$1;
+    private baseURL;
+    private tenantId;
+    private initialized;
+    private projectId;
+    constructor(config: Omit<MCPToolConfig$1, 'tenantId' | 'projectId'>);
+    setContext(tenantId: string, projectId: string, baseURL?: string): void;
+    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 AgentMcpConfig with the given configuration.
+     *
+     * @param config - The configuration for the AgentMcpConfig
+     * @returns A new AgentMcpConfig
+     *
+     * example:
+     * ```typescript
+     * const tool = new Tool({
+     *   id: 'tool-id',
+     *   name: 'Tool Name',
+     *   serverUrl: 'https://example.com/mcp',
+     * });
+     * const agentMcpConfig = tool.with({ selectedTools: ['tool-1', 'tool-2'], headers: { 'Authorization': 'Bearer token' } });
+     * ```
+     */
+    with(config: AgentMcpConfigInput): AgentMcpConfig;
+}
+
+declare class SubAgent implements SubAgentInterface {
+    config: SubAgentConfig;
+    readonly type: "internal";
+    private baseURL;
+    private tenantId;
+    private projectId;
+    private initialized;
+    constructor(config: SubAgentConfig);
+    setContext(tenantId: string, projectId: string, baseURL?: string): void;
+    getId(): string;
+    getName(): string;
+    getInstructions(): string;
+    /**
+     * Get the agent's description (the human-readable description field)
+     */
+    getDescription(): string;
+    getTools(): Record<string, AgentTool>;
+    getModels(): typeof this$1.config.models;
+    setModels(models: typeof this$1.config.models): void;
+    getTransfers(): SubAgentInterface[];
+    getSubAgentDelegates(): SubAgentInterface[];
+    getExternalAgentDelegates(): subAgentExternalAgentInterface[];
+    getTeamAgentDelegates(): subAgentTeamAgentInterface[];
+    getDelegates(): AllDelegateOutputInterface[];
+    getDataComponents(): DataComponentApiInsert[];
+    getArtifactComponents(): ArtifactComponentApiInsert[];
+    addTool(_name: string, tool: Tool): void;
+    addTransfer(...agents: SubAgentInterface[]): void;
+    addDelegate(...agents: AllDelegateInputInterface[]): void;
+    init(): Promise<void>;
+    private upsertAgent;
+    private saveToolsAndRelations;
+    private saveDataComponents;
+    private saveArtifactComponents;
+    private loadDataComponents;
+    private loadArtifactComponents;
+    private createFunctionTool;
+    private createTool;
+    private createDataComponent;
+    private createArtifactComponent;
+    private createAgentDataComponentRelation;
+    private createAgentArtifactComponentRelation;
+    private createAgentToolRelation;
+}
+
+/**
+ * Function signature for transfer conditions
+ */
+type TransferConditionFunction = (context: unknown) => boolean;
+/**
+ * Configuration for MCP server builders
+ */
+interface MCPServerConfig {
+    name: string;
+    description: string;
+    serverUrl: string;
+    id?: string;
+    parameters?: Record<string, z.ZodJSONSchema>;
+    credential?: CredentialReferenceApiInsert;
+    transport?: 'streamable_http' | 'sse';
+    activeTools?: string[];
+    headers?: Record<string, string>;
+    imageUrl?: string;
+}
+/**
+ * Configuration for component builders
+ */
+interface ComponentConfig {
+    id?: string;
+    name: string;
+    description: string;
+}
+interface ArtifactComponentConfig extends ComponentConfig {
+    props: Record<string, unknown> | z.ZodObject<any>;
+}
+interface DataComponentConfig extends ComponentConfig {
+    props: Record<string, unknown> | z.ZodObject<any>;
+    render?: {
+        component: string;
+        mockData: Record<string, unknown>;
+    };
+}
+interface StatusComponentConfig {
+    type: string;
+    description?: string;
+    detailsSchema?: Record<string, unknown> | z.ZodObject<any>;
+}
+type AgentMcpConfig = {
+    server: Tool;
+    selectedTools?: string[];
+    headers?: Record<string, string>;
+    toolPolicies?: Record<string, ToolPolicy>;
+};
+/**
+ * Input configuration for MCP tool customization
+ * Supports flexible tool selection with per-tool policies
+ */
+type AgentMcpConfigInput = {
+    /** Tools to enable from the MCP server - can be strings or objects with policies */
+    selectedTools?: McpToolSelection[];
+    /** Custom headers for MCP server requests */
+    headers?: Record<string, string>;
+};
+/**
+ * Creates a transfer configuration for agent transfers.
+ *
+ * Transfers allow one agent to hand off control to another agent
+ * based on optional conditions.
+ *
+ * @param targetAgent - The agent to transfer to
+ * @param description - Optional description of when/why to transfer
+ * @param condition - Optional function to determine if transfer should occur
+ * @returns A validated transfer configuration
+ *
+ * @example
+ * ```typescript
+ * // Simple transfer
+ * const transfer = transfer(supportAgent, 'Transfer to support');
+ *
+ * // Conditional transfer
+ * const conditionalHandoff = transfer(
+ *   specialistAgent,
+ *   'Transfer to specialist for complex issues',
+ *   (context) => context.complexity > 0.8
+ * );
+ * ```
+ */
+declare function transfer(targetAgent: SubAgent, description?: string, condition?: TransferConditionFunction): TransferConfig;
+
+type DataComponentConfigWithZod = Omit<DataComponentInsert, 'tenantId' | 'projectId' | 'props' | 'render'> & {
+    props?: Record<string, unknown> | z.ZodObject<any> | null;
+    render?: {
+        component: string;
+        mockData: Record<string, unknown>;
+    } | null;
+};
+interface DataComponentInterface {
+    config: Omit<DataComponentInsert, 'tenantId' | 'projectId'>;
+    init(): Promise<void>;
+    getId(): DataComponentInsert['id'];
+    getName(): DataComponentInsert['name'];
+    getDescription(): DataComponentInsert['description'];
+    getProps(): DataComponentInsert['props'];
+    setContext(tenantId: string, projectId: string, baseURL?: string): void;
+}
+declare class DataComponent implements DataComponentInterface {
+    config: Omit<DataComponentInsert, 'tenantId' | 'projectId'>;
+    private baseURL;
+    private tenantId;
+    private projectId;
+    private initialized;
+    private id;
+    constructor(config: DataComponentConfigWithZod);
+    setContext(tenantId: string, projectId: string, baseURL?: string): void;
+    getId(): string;
+    getName(): string;
+    getDescription(): string;
+    getProps(): DataComponentInsert['props'];
+    getRender(): DataComponentInsert['render'];
+    init(): Promise<void>;
+    private upsertDataComponent;
+}
+
+type ExternalAgentConfig = {
+    type?: 'external';
+    id: string;
+    name: string;
+    description: string;
+    baseUrl: string;
+    credentialReference?: CredentialReferenceApiInsert;
+};
+declare class ExternalAgent implements ExternalAgentInterface {
+    config: ExternalAgentConfig;
+    readonly type: "external";
+    private initialized;
+    private tenantId;
+    private projectId;
+    private baseURL;
+    constructor(config: ExternalAgentConfig);
+    /**
+     * Initialize the external agent by upserting it in the database
+     */
+    init(): Promise<void>;
+    setContext(tenantId: string, projectId: string): void;
+    getId(): string;
+    with(options: {
+        headers?: Record<string, string>;
+    }): subAgentExternalAgentInterface;
+    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;
+    getCredentialReference(): CredentialReferenceApiInsert | 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 FunctionToolInterface {
+    config: FunctionToolConfig;
+    getId(): string;
+    getName(): string;
+    getDescription(): string;
+    getInputSchema(): Record<string, unknown>;
+    getDependencies(): Record<string, string>;
+    getExecuteFunction(): (params: any) => Promise<any>;
+}
+declare class FunctionTool implements FunctionToolInterface {
+    config: FunctionToolConfig;
+    private id;
+    constructor(config: FunctionToolConfig);
+    getId(): string;
+    getName(): string;
+    getDescription(): string;
+    getInputSchema(): Record<string, unknown>;
+    getDependencies(): Record<string, string>;
+    getExecuteFunction(): (params: any) => Promise<any>;
+    serializeFunction(): {
+        id: string;
+        inputSchema: Record<string, unknown>;
+        executeCode: string;
+        dependencies: Record<string, string>;
+    };
+    serializeTool(): {
+        id: string;
+        name: string;
+        description: string;
+        functionId: string;
+    };
+}
+
+interface ArtifactComponentWithZodProps {
+    id: string;
+    name: string;
+    description: string;
+    props?: z.ZodObject<any>;
+}
+interface DataComponentWithZodProps {
+    id: string;
+    name: string;
+    description: string;
+    props?: z.ZodObject<any>;
+}
+
+/**
+ * Tool instance that may have additional metadata attached during agent processing
+ */
+type AgentTool = (Tool & {
+    selectedTools?: string[];
+    headers?: Record<string, string>;
+    toolPolicies?: Record<string, ToolPolicy>;
+}) | (FunctionTool & {
+    selectedTools?: string[];
+    headers?: Record<string, string>;
+    toolPolicies?: Record<string, ToolPolicy>;
+});
+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 AllDelegateInputInterface = SubAgentInterface | subAgentExternalAgentInterface | ExternalAgentInterface | AgentInterface | subAgentTeamAgentInterface;
+type AllDelegateOutputInterface = SubAgentInterface | subAgentExternalAgentInterface | subAgentTeamAgentInterface;
+type SubAgentCanUseType = Tool | AgentMcpConfig | FunctionTool;
+interface SubAgentConfig extends Omit<SubAgentApiInsert, 'projectId'> {
+    type?: 'internal';
+    canUse?: () => SubAgentCanUseType[];
+    canTransferTo?: () => SubAgentInterface[];
+    canDelegateTo?: () => AllDelegateInputInterface[];
+    dataComponents?: () => (DataComponentApiInsert | DataComponentInterface | DataComponentWithZodProps)[];
+    artifactComponents?: () => (ArtifactComponentApiInsert | ArtifactComponentInterface | ArtifactComponentWithZodProps)[];
+    conversationHistoryConfig?: AgentConversationHistoryConfig;
+}
+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: SubAgentInterface;
+    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: SubAgentInterface;
+    turnCount: number;
+    usage?: {
+        inputTokens: number;
+        outputTokens: number;
+        totalTokens?: number;
+    };
+    metadata?: {
+        toolCalls: ToolCall[];
+        transfers: TransferConfig[];
+    };
+}
+interface AgentConfig {
+    id: string;
+    name?: string;
+    description?: string;
+    defaultSubAgent: SubAgentInterface;
+    subAgents?: () => SubAgentInterface[];
+    contextConfig?: any;
+    credentials?: () => CredentialReferenceApiInsert[];
+    stopWhen?: AgentStopWhen;
+    prompt?: 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 SubAgentInterface {
+    config: SubAgentConfig;
+    type: 'internal';
+    init(): Promise<void>;
+    getId(): string;
+    getName(): string;
+    getDescription(): string;
+    getInstructions(): string;
+    getTools(): Record<string, AgentTool>;
+    getTransfers(): SubAgentInterface[];
+    getDelegates(): AllDelegateOutputInterface[];
+    getSubAgentDelegates(): SubAgentInterface[];
+    getExternalAgentDelegates(): subAgentExternalAgentInterface[];
+    getDataComponents(): DataComponentApiInsert[];
+    getArtifactComponents(): ArtifactComponentApiInsert[];
+    setContext(tenantId: string, projectId: string, baseURL?: string): void;
+    addTool(name: string, tool: any): void;
+    addTransfer(...agents: SubAgentInterface[]): void;
+    addDelegate(...agents: AllDelegateInputInterface[]): void;
+}
+interface ExternalAgentInterface {
+    config: ExternalAgentConfig;
+    type: 'external';
+    init(): Promise<void>;
+    getId(): string;
+    getName(): string;
+    getDescription(): string;
+    getBaseUrl(): string;
+    setContext?(tenantId: string, projectId: string): void;
+    with(options: {
+        headers?: Record<string, string>;
+    }): subAgentExternalAgentInterface;
+    getCredentialReferenceId(): string | undefined;
+    getCredentialReference(): CredentialReferenceApiInsert | undefined;
+}
+type subAgentExternalAgentInterface = {
+    externalAgent: ExternalAgentInterface;
+    headers?: Record<string, string>;
+};
+type subAgentTeamAgentInterface = {
+    agent: AgentInterface;
+    headers?: Record<string, string>;
+};
+interface AgentInterface {
+    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>;
+    getDefaultSubAgent(): SubAgentInterface | undefined;
+    getSubAgent(name: string): SubAgentInterface | undefined;
+    getSubAgents(): SubAgentInterface[];
+    toFullAgentDefinition(): Promise<FullAgentDefinition>;
+    with(options: {
+        headers?: Record<string, string>;
+    }): subAgentTeamAgentInterface;
+}
+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 {
+    private subAgents;
+    private agentMap;
+    private defaultSubAgent?;
+    private baseURL;
+    private tenantId;
+    private projectId;
+    private agentId;
+    private agentName;
+    private agentDescription?;
+    private initialized;
+    private contextConfig?;
+    private credentials?;
+    private models?;
+    private statusUpdateSettings?;
+    private prompt?;
+    private stopWhen?;
+    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 Agent to FullAgentDefinition format for the new agent endpoint
+     */
+    toFullAgentDefinition(): Promise<FullAgentDefinition>;
+    /**
+     * Initialize all tools in all agents (especially IPCTools that need MCP server URLs)
+     */
+    private initializeAllTools;
+    /**
+     * Initialize the agent and all agents in the backend using the new agent endpoint
+     */
+    init(): 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 agent
+     */
+    runWith(subAgentId: string, input: MessageInput, options?: GenerateOptions): Promise<RunResult>;
+    /**
+     * Get an agent by name (unified method for all agent types)
+     */
+    getSubAgent(name: string): SubAgentInterface | undefined;
+    /**
+     * Add an agent to the agent
+     */
+    addSubAgent(agent: SubAgentInterface): void;
+    /**
+     * Remove an agent from the agent
+     */
+    removeSubAgent(id: string): boolean;
+    /**
+     * Get all agents in the agent
+     */
+    getSubAgents(): SubAgentInterface[];
+    /**
+     * Get all agent ids (unified method for all agent types)
+     */
+    getSubAgentIds(): string[];
+    /**
+     * Set the default agent
+     */
+    setDefaultSubAgent(agent: SubAgentInterface): void;
+    /**
+     * Get the default agent
+     */
+    getDefaultSubAgent(): SubAgentInterface | undefined;
+    /**
+     * Get the agent ID
+     */
+    getId(): string;
+    getName(): string;
+    getDescription(): string | undefined;
+    getTenantId(): string;
+    /**
+     * Get the agent's model settingsuration
+     */
+    getModels(): typeof this.models;
+    /**
+     * Set the agent's model settingsuration
+     */
+    setModels(models: typeof this.models): void;
+    /**
+     * Get the agent's prompt configuration
+     */
+    getPrompt(): string | undefined;
+    /**
+     * Get the agent's stopWhen configuration
+     */
+    getStopWhen(): AgentStopWhen;
+    /**
+     * Get the agent's status updates configuration
+     */
+    getStatusUpdateSettings(): StatusUpdateSettings | undefined;
+    /**
+     * Get the summarizer model from the agent's model settings
+     */
+    getSummarizerModel(): ModelSettings | undefined;
+    /**
+     * Get agent statistics
+     */
+    getStats(): {
+        agentCount: number;
+        defaultSubAgent: string | null;
+        initialized: boolean;
+        agentId: string;
+        tenantId: string;
+    };
+    with(options: {
+        headers?: Record<string, string>;
+    }): subAgentTeamAgentInterface;
+    /**
+     * Validate the agent configuration
+     */
+    validate(): {
+        valid: boolean;
+        errors: string[];
+    };
+    private _init;
+    /**
+     * Type guard to check if an agent is an internal AgentInterface
+     */
+    isInternalAgent(agent: AllDelegateInputInterface): agent is SubAgentInterface;
+    /**
+     * Get project-level model settingsuration defaults
+     */
+    private getProjectModelDefaults;
+    /**
+     * Get project-level stopWhen configuration defaults
+     */
+    private getProjectStopWhenDefaults;
+    /**
+     * Apply model inheritance hierarchy: Project -> Agent -> Agent
+     */
+    private applyModelInheritance;
+    /**
+     * Apply stopWhen inheritance hierarchy: Project -> Agent -> Agent
+     */
+    private applyStopWhenInheritance;
+    /**
+     * Propagate agent-level model settings to agents (supporting partial inheritance)
+     */
+    private propagateModelSettingsToAgent;
+    /**
+     * Immediately propagate agent-level models to all agents during construction
+     */
+    private propagateImmediateModelSettings;
+    /**
+     * 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 createSubAgentRelations;
+    private createSubAgentRelation;
+}
+
+/**
+ * Project configuration interface for the SDK
+ */
+interface ProjectConfig {
+    id: string;
+    name: string;
+    description?: string;
+    models?: {
+        base?: ModelSettings;
+        structuredOutput?: ModelSettings;
+        summarizer?: ModelSettings;
+    };
+    stopWhen?: StopWhen;
+    agents?: () => Agent[];
+    tools?: () => Tool[];
+    externalAgents?: () => ExternalAgent[];
+    dataComponents?: () => DataComponent[];
+    artifactComponents?: () => ArtifactComponent[];
+    credentialReferences?: () => CredentialReferenceApiInsert[];
+}
+/**
+ * Project interface for operations
+ */
+interface ProjectInterface {
+    init(): Promise<void>;
+    setConfig(tenantId: string, apiUrl: string): void;
+    getId(): string;
+    getName(): string;
+    getDescription(): string | undefined;
+    getTenantId(): string;
+    getModels(): ProjectConfig['models'];
+    getStopWhen(): ProjectConfig['stopWhen'];
+    getAgents(): Agent[];
+    addAgent(agent: Agent): void;
+    removeAgent(id: string): boolean;
+    getStats(): {
+        projectId: string;
+        tenantId: string;
+        agentCount: number;
+        initialized: boolean;
+    };
+    validate(): {
+        valid: boolean;
+        errors: string[];
+    };
+}
+/**
+ * Project class for managing agent projects
+ *
+ * Projects are the top-level organizational unit that contains Agents, Sub Agents, and shared configurations.
+ * They provide model inheritance and execution limits that cascade down to Agents and Sub Agents.
+ *
+ * @example
+ * ```typescript
+ * const myProject = new Project({
+ *   id: 'customer-support-project',
+ *   name: 'Customer Support System',
+ *   description: 'Multi-agent customer support system',
+ *   models: {
+ *     base: { model: 'gpt-4.1-mini' },
+ *     structuredOutput: { model: 'gpt-4.1' }
+ *   },
+ *   stopWhen: {
+ *     transferCountIs: 10,
+ *     stepCountIs: 50
+ *   }
+ * });
+ *
+ * await myProject.init();
+ * ```
+ */
+declare class Project implements ProjectInterface {
+    readonly __type: "project";
+    private projectId;
+    private projectName;
+    private projectDescription?;
+    private tenantId;
+    private baseURL;
+    private apiKey?;
+    private initialized;
+    private models?;
+    private stopWhen?;
+    private agents;
+    private agentMap;
+    private credentialReferences?;
+    private projectTools;
+    private projectDataComponents;
+    private projectArtifactComponents;
+    private projectExternalAgents;
+    private externalAgentMap;
+    constructor(config: ProjectConfig);
+    /**
+     * Set or update the configuration (tenantId and apiUrl)
+     * This is used by the CLI to inject configuration from inkeep.config.ts
+     */
+    setConfig(tenantId: string, apiUrl: string, models?: ProjectConfig['models'], apiKey?: string): void;
+    /**
+     * Set credential references for the project
+     * This is used by the CLI to inject environment-specific credentials
+     */
+    setCredentials(credentials: Record<string, CredentialReferenceApiInsert>): void;
+    /**
+     * Initialize the project and create/update it in the backend using full project approach
+     */
+    init(): Promise<void>;
+    /**
+     * Get the project ID
+     */
+    getId(): string;
+    /**
+     * Get the project name
+     */
+    getName(): string;
+    /**
+     * Get the project description
+     */
+    getDescription(): string | undefined;
+    /**
+     * Get the tenant ID
+     */
+    getTenantId(): string;
+    /**
+     * Get the project's model configuration
+     */
+    getModels(): ProjectConfig['models'];
+    /**
+     * Set the project's model configuration
+     */
+    setModels(models: ProjectConfig['models']): void;
+    /**
+     * Get the project's stopWhen configuration
+     */
+    getStopWhen(): ProjectConfig['stopWhen'];
+    /**
+     * Set the project's stopWhen configuration
+     */
+    setStopWhen(stopWhen: ProjectConfig['stopWhen']): void;
+    /**
+     * Get credential tracking information
+     */
+    getCredentialTracking(): Promise<{
+        credentials: Record<string, any>;
+        usage: Record<string, Array<{
+            type: string;
+            id: string;
+            agentId?: string;
+        }>>;
+    }>;
+    getFullDefinition(): Promise<FullProjectDefinition>;
+    /**
+     * Get all agent in the project
+     */
+    getAgents(): Agent[];
+    /**
+     * Get all external agents in the project
+     */
+    getExternalAgents(): ExternalAgent[];
+    /**
+     * Get an external agent by ID
+     */
+    getExternalAgent(id: string): ExternalAgent | undefined;
+    /**
+     * Add an external agent to the project
+     */
+    addExternalAgent(externalAgent: ExternalAgent): void;
+    /**
+     * Remove an external agent from the project
+     */
+    removeExternalAgent(id: string): boolean;
+    /**
+     * Get an agent by ID
+     */
+    getAgent(id: string): Agent | undefined;
+    /**
+     * Add an agent to the project
+     */
+    addAgent(agent: Agent): void;
+    /**
+     * Remove an agent from the project
+     */
+    removeAgent(id: string): boolean;
+    /**
+     * Get project statistics
+     */
+    getStats(): {
+        projectId: string;
+        tenantId: string;
+        agentCount: number;
+        initialized: boolean;
+    };
+    /**
+     * Validate the project configuration
+     */
+    validate(): {
+        valid: boolean;
+        errors: string[];
+    };
+    /**
+     * Convert the Project to FullProjectDefinition format
+     */
+    private toFullProjectDefinition;
+}
+
+type StatusComponentConfigWithZod = Omit<StatusComponent$1, 'detailsSchema'> & {
+    detailsSchema?: Record<string, unknown> | z.ZodObject<any>;
+};
+interface StatusComponentInterface {
+    config: StatusComponent$1;
+    getType(): string;
+    getDescription(): string | undefined;
+    getDetailsSchema(): StatusComponent$1['detailsSchema'];
+}
+declare class StatusComponent implements StatusComponentInterface {
+    config: StatusComponent$1;
+    constructor(config: StatusComponentConfigWithZod);
+    getType(): string;
+    getDescription(): string | undefined;
+    getDetailsSchema(): StatusComponent$1['detailsSchema'];
+}
+
+/**
+ * Helper function to create agent - OpenAI style
+ */
+declare function agent(config: AgentConfig): Agent;
+/**
+ * Helper function to create projects - OpenAI style
+ *
+ * Projects are the top-level organizational unit that contains Agents, Sub Agents, and shared configurations.
+ * They provide model inheritance and execution limits that cascade down to Agents and Sub Agents.
+ *
+ * @param config - Project configuration
+ * @returns A new Project instance
+ *
+ * @example
+ * ```typescript
+ * const customerSupport = project({
+ *   id: 'customer-support-project',
+ *   name: 'Customer Support System',
+ *   description: 'Multi-agent customer support system',
+ *   models: {
+ *     base: { model: 'gpt-4.1-mini' },
+ *     structuredOutput: { model: 'gpt-4.1' }
+ *   },
+ *   stopWhen: {
+ *     transferCountIs: 10,
+ *     stepCountIs: 50
+ *   },
+ *   agent: () => [
+ *     agent({
+ *       id: 'support-agent',
+ *       name: 'Support Agent',
+ *       // ... agent config
+ *     })
+ *   ]
+ * });
+ * ```
+ */
+declare function project(config: ProjectConfig): Project;
+/**
+ * Creates a new agent with stable ID enforcement.
+ *
+ * Agents require explicit stable IDs to ensure consistency across deployments.
+ * This is different from tools which auto-generate IDs from their names.
+ *
+ * @param config - Agent configuration including required stable ID
+ * @returns A new SubAgent instance
+ * @throws {Error} If config.id is not provided
+ *
+ * @example
+ * ```typescript
+ * const myAgent = agent({
+ *   id: 'customer-support-agent',
+ *   name: 'Customer Support',
+ *   prompt: 'Help customers with their questions'
+ * });
+ * ```
+ */
+declare function subAgent(config: SubAgentConfig): SubAgent;
+/**
+ * Creates a credential reference for authentication.
+ *
+ * Credentials are used to authenticate with external services.
+ * They should be stored securely and referenced by ID.
+ *
+ * @param config - Credential configuration
+ * @returns A validated credential reference
+ *
+ * @example
+ * ```typescript
+ * const apiCredential = credential({
+ *   id: 'github-token',
+ *   name: 'GitHub Token',
+ *   type: 'bearer',
+ *   value: process.env.GITHUB_TOKEN
+ * });
+ * ```
+ */
+declare function credential(config: CredentialReferenceApiInsert): {
+    id: string;
+    name: string;
+    credentialStoreId: string;
+    type: "nango" | "memory" | "keychain";
+    createdAt?: string | undefined;
+    updatedAt?: string | undefined;
+    retrievalParams?: Record<string, unknown> | null | undefined;
+};
+/**
+ * Creates an MCP (Model Context Protocol) server for tool functionality.
+ *
+ * MCP servers provide tool functionality through a standardized protocol.
+ * They can be remote services accessed via HTTP/WebSocket.
+ *
+ * @param config - MCP server configuration
+ * @returns A Tool instance configured as an MCP server
+ * @throws {Error} If serverUrl is not provided
+ *
+ * @example
+ * ```typescript
+ * // Remote MCP server
+ * const apiServer = mcpServer({
+ *   name: 'external_api',
+ *   description: 'External API service',
+ *   serverUrl: 'https://api.example.com/mcp'
+ * });
+ *
+ * // With authentication
+ * const secureServer = mcpServer({
+ *   name: 'secure_api',
+ *   description: 'Secure API service',
+ *   serverUrl: 'https://secure.example.com/mcp',
+ *   credential: credential({
+ *     id: 'api-key',
+ *     name: 'API Key',
+ *     type: 'bearer',
+ *     value: process.env.API_KEY
+ *   })
+ * });
+ * ```
+ */
+declare function mcpServer(config: MCPServerConfig): Tool;
+/**
+ * Creates an MCP tool from a raw configuration object.
+ *
+ * This is a low-level builder for advanced use cases where you need
+ * full control over the MCPToolConfig. For most cases, use `mcpServer()`.
+ *
+ * @param config - Complete MCP tool configuration
+ * @returns A Tool instance
+ *
+ * @example
+ * ```typescript
+ * const customTool = mcpTool({
+ *   id: 'custom-tool',
+ *   name: 'Custom Tool',
+ *   serverUrl: 'https://example.com/mcp',
+ *   transport: { type: 'stdio' }
+ * });
+ * ```
+ */
+declare function mcpTool(config: MCPToolConfig$1): Tool;
+/**
+ * Creates an artifact component with automatic ID generation.
+ *
+ * Artifact components represent structured UI components that can
+ * be rendered with different levels of detail (summary vs full).
+ *
+ * @param config - Artifact component configuration
+ * @returns An ArtifactComponent instance
+ *
+ * @example
+ * ```typescript
+ * const productCard = artifactComponent({
+ *   name: 'Product Card',
+ *   description: 'Display product information',
+ *   props: {
+ *     type: 'object',
+ *     properties: {
+ *       title: { type: 'string', inPreview: true },
+ *       price: { type: 'string', inPreview: true },
+ *       description: { type: 'string' },
+ *       image: { type: 'string' }
+ *     }
+ *   }
+ * });
+ * ```
+ */
+declare function artifactComponent(config: ArtifactComponentConfig): ArtifactComponent;
+/**
+ * Creates a data component with automatic ID generation.
+ *
+ * Data components represent structured data that can be
+ * passed between agents or used in processing.
+ *
+ * @param config - Data component configuration
+ * @returns A DataComponent instance
+ *
+ * @example
+ * ```typescript
+ * const userProfile = dataComponent({
+ *   name: 'User Profile',
+ *   description: 'User profile data',
+ *   props: {
+ *     userId: '123',
+ *     name: 'John Doe',
+ *     email: 'john@example.com'
+ *   }
+ * });
+ * ```
+ */
+declare function dataComponent(config: DataComponentConfig): DataComponent;
+/**
+ * Creates a status component for structured status updates.
+ *
+ * Status components define the structure of status updates
+ * that agents can generate during long-running operations.
+ *
+ * @param config - Status component configuration
+ * @returns A StatusComponent instance
+ *
+ * @example
+ * ```typescript
+ * import { z } from 'zod';
+ *
+ * const toolCallStatus = statusComponent({
+ *   type: 'tool_call_summary',
+ *   description: 'Summary of a tool execution',
+ *   detailsSchema: z.object({
+ *     tool_name: z.string(),
+ *     summary: z.string(),
+ *     status: z.enum(['success', 'error', 'in_progress'])
+ *   })
+ * });
+ * ```
+ */
+declare function statusComponent(config: StatusComponentConfig): StatusComponent;
+/**
+ * (deprecated in favor of mcpTool.with()) Creates an agent MCP configuration.
+ *
+ * Agent MCP configurations are used to configure the MCP server for an agent.
+ *
+ * @param config - Agent MCP configuration
+ * @returns An AgentMcpConfig instance
+ */
+declare function agentMcp(config: AgentMcpConfig): AgentMcpConfig;
+/**
+ * Creates a function tool that executes user-defined code in a sandboxed environment.
+ *
+ * Function tools allow users to define custom logic that runs securely in isolated
+ * environments. Dependencies are installed automatically in the sandbox.
+ *
+ * @param config - Function tool configuration
+ * @returns A FunctionTool instance
+ *
+ * @example
+ * ```typescript
+ * const calculatorTool = functionTool({
+ *   name: 'calculator',
+ *   description: 'Performs basic math operations',
+ *   inputSchema: {
+ *     type: 'object',
+ *     properties: {
+ *       operation: { type: 'string', enum: ['add', 'subtract', 'multiply', 'divide'] },
+ *       a: { type: 'number' },
+ *       b: { type: 'number' }
+ *     },
+ *     required: ['operation', 'a', 'b']
+ *   },
+ *   dependencies: {
+ *     'lodash': '^4.17.21'
+ *   },
+ *   execute: async (params) => {
+ *     const { operation, a, b } = params;
+ *     switch (operation) {
+ *       case 'add': return { result: a + b };
+ *       case 'subtract': return { result: a - b };
+ *       case 'multiply': return { result: a * b };
+ *       case 'divide': return { result: a / b };
+ *       default: throw new Error(`Unknown operation: ${operation}`);
+ *     }
+ *   }
+ * });
+ * ```
+ */
+declare function functionTool(config: FunctionToolConfig): FunctionTool;
+
+/**
+ * Credential Reference System
+ *
+ * This module provides a way to reference credentials by ID without including
+ * the full credential definition in the code. Credentials are resolved from
+ * environment files at runtime during the push operation.
+ */
+/**
+ * Represents a reference to a credential by its ID.
+ * The actual credential will be resolved from the environment file at push time.
+ */
+interface CredentialReference {
+    __type: 'credential-ref';
+    id: string;
+}
+/**
+ * Create a reference to a credential by its ID.
+ * The credential must be defined in the environment files.
+ *
+ * @param id - The ID of the credential to reference
+ * @returns A credential reference that will be resolved at push time
+ *
+ * @example
+ * ```typescript
+ * const apiKeyRef = credentialRef('api-key');
+ *
+ * const fetchDef = fetchDefinition({
+ *   credential: apiKeyRef,
+ *   // ...
+ * });
+ * ```
+ */
+declare function credentialRef<T extends string = string>(id: T): CredentialReference;
+/**
+ * Type guard to check if a value is a credential reference
+ */
+declare function isCredentialReference(value: any): value is CredentialReference;
+/**
+ * Type helper to extract credential IDs from environment configuration
+ */
+type ExtractCredentialIds<T> = T extends {
+    credentials?: infer C;
+} ? C extends Record<string, any> ? keyof C : never : never;
+/**
+ * Type helper to create a union of all available credential IDs from multiple environments
+ */
+type UnionCredentialIds<T extends Record<string, any>> = {
+    [K in keyof T]: ExtractCredentialIds<T[K]>;
+}[keyof T];
+/**
+ * Type helper to extract tool IDs from environment configuration
+ */
+type ExtractMcpServerIds<T> = T extends {
+    mcpServers?: infer T;
+} ? T extends Record<string, any> ? keyof T : never : never;
+/**
+ * Type helper to create a union of all available tool IDs from multiple environments
+ */
+type UnionMcpServerIds<T extends Record<string, any>> = {
+    [K in keyof T]: ExtractMcpServerIds<T[K]>;
+}[keyof T];
+
+interface EnvironmentSettingsConfig {
+    credentials?: {
+        [settingId: string]: CredentialReferenceApiInsert;
+    };
+    mcpServers?: {
+        [mcpServerId: string]: Tool;
+    };
+}
+/**
+ * Create a setting helper with TypeScript autocomplete
+ */
+declare function createEnvironmentSettings<T extends Record<string, EnvironmentSettingsConfig>>(environments: T): {
+    getEnvironmentCredential: (key: UnionCredentialIds<T>) => CredentialReferenceApiInsert;
+    getEnvironmentMcp: (key: UnionMcpServerIds<T>) => Tool;
+    getEnvironmentSetting: (key: UnionCredentialIds<T>) => CredentialReferenceApiInsert;
+};
+/**
+ * Create type-safe environment configurations
+ */
+declare function registerEnvironmentSettings<T extends EnvironmentSettingsConfig>(config: T): T;
+
+/**
+ * Client-side functions for interacting with the Evaluations API
+ * These functions make HTTP requests to the server instead of direct database calls
+ */
+declare function listDatasets(tenantId: string, projectId: string, apiUrl: string, apiKey?: string): Promise<unknown[]>;
+declare function getDataset(tenantId: string, projectId: string, datasetId: string, apiUrl: string, apiKey?: string): Promise<unknown | null>;
+declare function createDataset(tenantId: string, projectId: string, apiUrl: string, datasetData: Record<string, unknown>, apiKey?: string): Promise<unknown>;
+declare function updateDataset(tenantId: string, projectId: string, datasetId: string, apiUrl: string, updateData: Record<string, unknown>, apiKey?: string): Promise<unknown>;
+declare function deleteDataset(tenantId: string, projectId: string, datasetId: string, apiUrl: string, apiKey?: string): Promise<void>;
+declare function listDatasetItems(tenantId: string, projectId: string, datasetId: string, apiUrl: string, apiKey?: string): Promise<unknown[]>;
+declare function getDatasetItem(tenantId: string, projectId: string, datasetId: string, itemId: string, apiUrl: string, apiKey?: string): Promise<unknown | null>;
+declare function createDatasetItem(tenantId: string, projectId: string, datasetId: string, apiUrl: string, itemData: Record<string, unknown>, apiKey?: string): Promise<unknown>;
+declare function createDatasetItems(tenantId: string, projectId: string, datasetId: string, apiUrl: string, itemsData: Record<string, unknown>[], apiKey?: string): Promise<unknown[]>;
+declare function updateDatasetItem(tenantId: string, projectId: string, datasetId: string, itemId: string, apiUrl: string, updateData: Record<string, unknown>, apiKey?: string): Promise<unknown>;
+declare function deleteDatasetItem(tenantId: string, projectId: string, datasetId: string, itemId: string, apiUrl: string, apiKey?: string): Promise<void>;
+declare function listEvaluators(tenantId: string, projectId: string, apiUrl: string, apiKey?: string): Promise<unknown[]>;
+declare function getEvaluator(tenantId: string, projectId: string, evaluatorId: string, apiUrl: string, apiKey?: string): Promise<unknown | null>;
+declare function createEvaluator(tenantId: string, projectId: string, apiUrl: string, evaluatorData: Record<string, unknown>, apiKey?: string): Promise<unknown>;
+declare function updateEvaluator(tenantId: string, projectId: string, evaluatorId: string, apiUrl: string, updateData: Record<string, unknown>, apiKey?: string): Promise<unknown>;
+declare function deleteEvaluator(tenantId: string, projectId: string, evaluatorId: string, apiUrl: string, apiKey?: string): Promise<void>;
+declare function listEvaluationSuiteConfigs(tenantId: string, projectId: string, apiUrl: string, apiKey?: string): Promise<unknown[]>;
+declare function getEvaluationSuiteConfig(tenantId: string, projectId: string, configId: string, apiUrl: string, apiKey?: string): Promise<unknown | null>;
+declare function createEvaluationSuiteConfig(tenantId: string, projectId: string, apiUrl: string, configData: Record<string, unknown>, apiKey?: string): Promise<unknown>;
+declare function updateEvaluationSuiteConfig(tenantId: string, projectId: string, configId: string, apiUrl: string, updateData: Record<string, unknown>, apiKey?: string): Promise<unknown>;
+declare function deleteEvaluationSuiteConfig(tenantId: string, projectId: string, configId: string, apiUrl: string, apiKey?: string): Promise<void>;
+declare function listEvaluationSuiteConfigEvaluators(tenantId: string, projectId: string, configId: string, apiUrl: string, apiKey?: string): Promise<unknown[]>;
+declare function addEvaluatorToSuiteConfig(tenantId: string, projectId: string, configId: string, evaluatorId: string, apiUrl: string, apiKey?: string): Promise<unknown>;
+declare function removeEvaluatorFromSuiteConfig(tenantId: string, projectId: string, configId: string, evaluatorId: string, apiUrl: string, apiKey?: string): Promise<void>;
+declare function getEvaluationResult(tenantId: string, projectId: string, resultId: string, apiUrl: string, apiKey?: string): Promise<unknown | null>;
+declare function createEvaluationResult(tenantId: string, projectId: string, apiUrl: string, resultData: Record<string, unknown>, apiKey?: string): Promise<unknown>;
+declare function updateEvaluationResult(tenantId: string, projectId: string, resultId: string, apiUrl: string, updateData: Record<string, unknown>, apiKey?: string): Promise<unknown>;
+declare function deleteEvaluationResult(tenantId: string, projectId: string, resultId: string, apiUrl: string, apiKey?: string): Promise<void>;
+
+/**
+ * Client-side functions for interacting with the Full Project API
+ * These functions make HTTP requests to the server instead of direct database calls
+ */
+
+/**
+ * Create a full project via HTTP API
+ */
+declare function createFullProjectViaAPI(tenantId: string, apiUrl: string, projectData: FullProjectDefinition, apiKey?: string): Promise<FullProjectDefinition>;
+/**
+ * Update a full project via HTTP API (upsert behavior)
+ */
+declare function updateFullProjectViaAPI(tenantId: string, apiUrl: string, projectId: string, projectData: FullProjectDefinition, apiKey?: string): Promise<FullProjectDefinition>;
+/**
+ * Get a full project via HTTP API
+ */
+declare function getFullProjectViaAPI(tenantId: string, apiUrl: string, projectId: string, apiKey?: string): Promise<FullProjectDefinition | null>;
+/**
+ * Delete a full project via HTTP API
+ */
+declare function deleteFullProjectViaAPI(tenantId: string, apiUrl: string, projectId: string, apiKey?: string): Promise<void>;
+
+declare class Runner {
+    /**
+     * Run an agent until completion, handling transfers and tool calls
+     * Similar to OpenAI's Runner.run() pattern
+     * NOTE: This now requires an agent instead of an agent
+     */
+    static run(agent: AgentInterface, messages: MessageInput, options?: GenerateOptions): Promise<RunResult>;
+    /**
+     * Stream an agent's response
+     */
+    static stream(agent: AgentInterface, messages: MessageInput, options?: GenerateOptions): Promise<StreamResponse>;
+    /**
+     * Execute multiple agent in parallel and return the first successful result
+     */
+    static raceAgents(agent: AgentInterface[], messages: MessageInput, options?: GenerateOptions): Promise<RunResult>;
+    private static normalizeToMessageHistory;
+    /**
+     * Validate agent configuration before running
+     */
+    static validateAgent(agent: AgentInterface): {
+        valid: boolean;
+        errors: string[];
+    };
+    /**
+     * Get execution statistics for an agent
+     */
+    static getExecutionStats(agent: AgentInterface, messages: MessageInput, options?: GenerateOptions): Promise<{
+        estimatedTurns: number;
+        estimatedTokens: number;
+        subAgentCount: number;
+        defaultSubAgent: string | undefined;
+    }>;
+}
+declare const run: typeof Runner.run;
+declare const stream: typeof Runner.stream;
+declare const raceAgents: typeof Runner.raceAgents;
+
+export { type AgentConfig, AgentError, type AgentInterface, type AgentResponse, type AgentTool, type AllDelegateInputInterface, type AllDelegateOutputInterface, 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, StatusComponent, type StatusComponentInterface, 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, addEvaluatorToSuiteConfig, agent, agentMcp, artifactComponent, createDataset, createDatasetItem, createDatasetItems, createEnvironmentSettings, createEvaluationResult, createEvaluationSuiteConfig, createEvaluator, createFullProjectViaAPI, credential, credentialRef, dataComponent, deleteDataset, deleteDatasetItem, deleteEvaluationResult, deleteEvaluationSuiteConfig, deleteEvaluator, deleteFullProjectViaAPI, externalAgent, externalAgents, functionTool, getDataset, getDatasetItem, getEvaluationResult, getEvaluationSuiteConfig, getEvaluator, getFullProjectViaAPI, isCredentialReference, listDatasetItems, listDatasets, listEvaluationSuiteConfigEvaluators, listEvaluationSuiteConfigs, listEvaluators, mcpServer, mcpTool, project, raceAgents, registerEnvironmentSettings, removeEvaluatorFromSuiteConfig, run, statusComponent, stream, subAgent, type subAgentExternalAgentInterface, type subAgentTeamAgentInterface, transfer, updateDataset, updateDatasetItem, updateEvaluationResult, updateEvaluationSuiteConfig, updateEvaluator, updateFullProjectViaAPI };