@inkeep/agents-sdk 0.39.2 → 0.39.3

package/dist/index.d.cts

@@ -1,129 +1,132 @@
-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';
+import { ANTHROPIC_MODELS, AgentConversationHistoryConfig, AgentStopWhen, ArtifactComponentApiInsert, ArtifactComponentInsert, CredentialReferenceApiInsert, DataComponentApiInsert, DataComponentInsert, FullAgentDefinition, FullProjectDefinition, FunctionToolConfig, GOOGLE_MODELS, MCPToolConfig as MCPToolConfig$1, McpToolSelection, McpTransportConfig, ModelSettings, OPENAI_MODELS, StatusComponent as StatusComponent$1, StatusUpdateSettings, StopWhen, SubAgentApiInsert, ToolInsert, ToolPolicy } from "@inkeep/agents-core";
+import { z } from "zod";
 
+//#region src/artifact-component.d.ts
 type ArtifactComponentConfigWithZod = Omit<ArtifactComponentInsert, 'tenantId' | 'projectId' | 'props'> & {
-    props?: Record<string, unknown> | z.ZodObject<any> | null;
+  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;
+  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;
-}
-
+  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;
+}
+//#endregion
+//#region src/tool.d.ts
 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;
+  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;
-}
-
+  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;
+}
+//#endregion
+//#region src/subAgent.d.ts
 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;
-}
-
+  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.config.models;
+  setModels(models: typeof this.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;
+}
+//#endregion
+//#region src/builders.d.ts
 /**
  * Function signature for transfer conditions
  */
@@ -132,60 +135,60 @@ 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;
+  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;
+  id?: string;
+  name: string;
+  description: string;
 }
 interface ArtifactComponentConfig extends ComponentConfig {
-    props: Record<string, unknown> | z.ZodObject<any>;
+  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>;
-    };
+  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: string;
+  description?: string;
+  detailsSchema?: Record<string, unknown> | z.ZodObject<any>;
 }
 type AgentMcpConfig = {
-    server: Tool;
-    selectedTools?: string[];
-    headers?: Record<string, string>;
-    toolPolicies?: Record<string, ToolPolicy>;
+  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
-     * - undefined or null: all tools enabled (no filtering)
-     * - []: zero tools enabled (explicit empty selection)
-     * - ['tool1', 'tool2']: specific tools enabled
-     */
-    selectedTools?: McpToolSelection[] | null;
-    /** Custom headers for MCP server requests */
-    headers?: Record<string, string>;
+  /**
+   * Tools to enable from the MCP server - can be strings or objects with policies
+   * - undefined or null: all tools enabled (no filtering)
+   * - []: zero tools enabled (explicit empty selection)
+   * - ['tool1', 'tool2']: specific tools enabled
+   */
+  selectedTools?: McpToolSelection[] | null;
+  /** Custom headers for MCP server requests */
+  headers?: Record<string, string>;
 };
 /**
  * Creates a transfer configuration for agent transfers.
@@ -212,86 +215,88 @@ type AgentMcpConfigInput = {
  * ```
  */
 declare function transfer(targetAgent: SubAgent, description?: string, condition?: TransferConditionFunction): TransferConfig;
-
+//#endregion
+//#region src/data-component.d.ts
 type DataComponentConfigWithZod = Omit<DataComponentInsert, 'tenantId' | 'projectId' | 'props' | 'render'> & {
-    props?: Record<string, unknown> | z.ZodObject<any> | null;
-    render?: {
-        component: string;
-        mockData: Record<string, unknown>;
-    } | null;
+  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;
+  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;
-}
-
+  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;
+}
+//#endregion
+//#region src/external-agent.d.ts
 type ExternalAgentConfig = {
-    type?: 'external';
-    id: string;
-    name: string;
-    description: string;
-    baseUrl: string;
-    credentialReference?: CredentialReferenceApiInsert;
+  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;
+  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()
@@ -301,545 +306,547 @@ declare function externalAgent(config: ExternalAgentConfig): ExternalAgent;
  * Helper function to create multiple external agents
  */
 declare function externalAgents(configs: Record<string, ExternalAgentConfig>): Record<string, ExternalAgent>;
-
+//#endregion
+//#region src/function-tool.d.ts
 interface FunctionToolInterface {
-    config: FunctionToolConfig;
-    getId(): string;
-    getName(): string;
-    getDescription(): string;
-    getInputSchema(): Record<string, unknown>;
-    getDependencies(): Record<string, string>;
-    getExecuteFunction(): (params: any) => Promise<any>;
+  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 {
+  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;
-    props?: z.ZodObject<any>;
+    functionId: string;
+  };
+}
+//#endregion
+//#region src/types.d.ts
+interface ArtifactComponentWithZodProps {
+  id: string;
+  name: string;
+  description: string;
+  props?: z.ZodObject<any>;
 }
 interface DataComponentWithZodProps {
-    id: string;
-    name: string;
-    description: string;
-    props?: z.ZodObject<any>;
+  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>;
+  selectedTools?: string[];
+  headers?: Record<string, string>;
+  toolPolicies?: Record<string, ToolPolicy>;
 }) | (FunctionTool & {
-    selectedTools?: string[];
-    headers?: Record<string, string>;
-    toolPolicies?: Record<string, ToolPolicy>;
+  selectedTools?: string[];
+  headers?: Record<string, string>;
+  toolPolicies?: Record<string, ToolPolicy>;
 });
 interface UserMessage {
-    role: 'user';
-    content: string;
+  role: 'user';
+  content: string;
 }
 interface AssistantMessage {
-    role: 'assistant';
-    content: string;
-    toolCalls?: ToolCall[];
+  role: 'assistant';
+  content: string;
+  toolCalls?: ToolCall[];
 }
 interface ToolMessage {
-    role: 'tool';
-    content: string;
-    toolCallId: string;
+  role: 'tool';
+  content: string;
+  toolCallId: string;
 }
 interface SystemMessage {
-    role: 'system';
-    content: string;
+  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;
-    };
+  id: string;
+  type: 'function';
+  function: {
+    name: string;
+    arguments: string;
+  };
 }
 interface ToolResult {
-    id: string;
-    result: any;
-    error?: string;
+  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;
+  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;
+  execute: (params: any) => Promise<any>;
+  parameters?: Record<string, any>;
+  schema?: z.ZodJSONSchema;
 }
 interface ServerConfig {
-    type: string;
-    version?: string;
+  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;
+  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;
+  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>;
+  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')[];
+  schemas: RequestSchemaDefinition;
+  optional?: ('body' | 'headers' | 'query' | 'params')[];
 }
 interface TransferConfig {
-    agent: SubAgentInterface;
-    description?: string;
-    condition?: (context: any) => boolean;
+  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>;
+  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>;
+  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>;
+  textStream?: AsyncGenerator<string>;
+  eventStream?: AsyncGenerator<StreamEvent>;
 }
 interface StreamEvent {
-    type: 'text' | 'tool_call' | 'transfer' | 'error' | 'done';
-    data: any;
-    timestamp: Date;
+  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[];
-    };
+  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;
+  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);
+  code?: string | undefined;
+  details?: any | undefined;
+  constructor(message: string, code?: string | undefined, details?: any | undefined);
 }
 declare class MaxTurnsExceededError extends AgentError {
-    constructor(maxTurns: number);
+  constructor(maxTurns: number);
 }
 declare class ToolExecutionError extends AgentError {
-    constructor(toolName: string, originalError: Error);
+  constructor(toolName: string, originalError: Error);
 }
 declare class TransferError extends AgentError {
-    constructor(sourceAgent: string, targetAgent: string, reason: string);
+  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;
+  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;
+  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>;
+  externalAgent: ExternalAgentInterface;
+  headers?: Record<string, string>;
 };
 type subAgentTeamAgentInterface = {
-    agent: AgentInterface;
-    headers?: Record<string, string>;
+  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;
+  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;
-            };
-        };
+  name: string;
+  description: string;
+  config: {
+    type: 'mcp';
+    mcp: {
+      server: {
+        url: string;
+      };
     };
-    parameters?: Record<string, any>;
+  };
+  parameters?: Record<string, any>;
 }
 interface BuilderRelationConfig {
-    targetAgent: string;
-    relationType: 'transfer' | 'delegate';
+  targetAgent: string;
+  relationType: 'transfer' | 'delegate';
 }
 interface BuilderAgentConfig {
-    name: string;
-    description: string;
-    instructions: string;
-    tools: BuilderToolConfig[];
-    relations?: BuilderRelationConfig[];
-}
-
+  name: string;
+  description: string;
+  instructions: string;
+  tools: BuilderToolConfig[];
+  relations?: BuilderRelationConfig[];
+}
+//#endregion
+//#region src/agent.d.ts
 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 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;
+}
+//#endregion
+//#region src/project.d.ts
 /**
  * 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[];
+  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[];
-    };
+  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
@@ -867,154 +874,156 @@ interface ProjectInterface {
  * ```
  */
 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;
-}
-
+  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;
+}
+//#endregion
+//#region src/status-component.d.ts
 type StatusComponentConfigWithZod = Omit<StatusComponent$1, 'detailsSchema'> & {
-    detailsSchema?: Record<string, unknown> | z.ZodObject<any>;
+  detailsSchema?: Record<string, unknown> | z.ZodObject<any>;
 };
 interface StatusComponentInterface {
-    config: StatusComponent$1;
-    getType(): string;
-    getDescription(): string | undefined;
-    getDetailsSchema(): StatusComponent$1['detailsSchema'];
+  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'];
+  config: StatusComponent$1;
+  constructor(config: StatusComponentConfigWithZod);
+  getType(): string;
+  getDescription(): string | undefined;
+  getDetailsSchema(): StatusComponent$1['detailsSchema'];
 }
-
+//#endregion
+//#region src/builderFunctions.d.ts
 /**
  * Helper function to create agent - OpenAI style
  */
@@ -1093,16 +1102,16 @@ declare function subAgent(config: SubAgentConfig): SubAgent;
  * ```
  */
 declare function credential(config: CredentialReferenceApiInsert): {
-    id: string;
-    name: string;
-    credentialStoreId: string;
-    type: "nango" | "memory" | "keychain";
-    createdAt?: string | undefined;
-    updatedAt?: string | undefined;
-    userId?: string | null | undefined;
-    retrievalParams?: Record<string, unknown> | null | undefined;
-    toolId?: string | null | undefined;
-    createdBy?: string | null | undefined;
+  id: string;
+  name: string;
+  credentialStoreId: string;
+  type: "memory" | "keychain" | "nango";
+  retrievalParams?: Record<string, unknown> | null | undefined;
+  toolId?: string | null | undefined;
+  userId?: string | null | undefined;
+  createdBy?: string | null | undefined;
+  createdAt?: string | undefined;
+  updatedAt?: string | undefined;
 };
 /**
  * Creates an MCP (Model Context Protocol) server for tool functionality.
@@ -1282,7 +1291,8 @@ declare function agentMcp(config: AgentMcpConfig): AgentMcpConfig;
  * ```
  */
 declare function functionTool(config: FunctionToolConfig): FunctionTool;
-
+//#endregion
+//#region src/credential-provider.d.ts
 /**
  * InkeepCredentialProvider - Abstraction for Credential Management
  *
@@ -1309,23 +1319,23 @@ declare function functionTool(config: FunctionToolConfig): FunctionTool;
  * This is a simplified version for SDK customers
  */
 interface CredentialStore {
-    /** Unique identifier for this credential store */
-    readonly id: string;
-    /** Type of credential store */
-    readonly type: CredentialProviderType;
-    /** Get a credential by key */
-    get(key: string): Promise<string | null>;
-    /** Set a credential */
-    set(key: string, value: string, metadata?: Record<string, string>): Promise<void>;
-    /** Check if a credential exists */
-    has(key: string): Promise<boolean>;
-    /** Delete a credential */
-    delete(key: string): Promise<boolean>;
-    /** Check if the credential store is available */
-    checkAvailability(): Promise<{
-        available: boolean;
-        reason?: string;
-    }>;
+  /** Unique identifier for this credential store */
+  readonly id: string;
+  /** Type of credential store */
+  readonly type: CredentialProviderType;
+  /** Get a credential by key */
+  get(key: string): Promise<string | null>;
+  /** Set a credential */
+  set(key: string, value: string, metadata?: Record<string, string>): Promise<void>;
+  /** Check if a credential exists */
+  has(key: string): Promise<boolean>;
+  /** Delete a credential */
+  delete(key: string): Promise<boolean>;
+  /** Check if the credential store is available */
+  checkAvailability(): Promise<{
+    available: boolean;
+    reason?: string;
+  }>;
 }
 /**
  * Supported credential provider types
@@ -1335,40 +1345,40 @@ type CredentialProviderType = 'memory' | 'keychain' | 'nango' | 'custom';
  * Configuration for memory-based credential storage
  */
 interface MemoryCredentialConfig {
-    type: 'memory';
-    /** Optional store ID (defaults to 'memory-default') */
-    id?: string;
+  type: 'memory';
+  /** Optional store ID (defaults to 'memory-default') */
+  id?: string;
 }
 /**
  * Configuration for keychain-based credential storage
  */
 interface KeychainCredentialConfig {
-    type: 'keychain';
-    /** Optional store ID (defaults to 'keychain-default') */
-    id?: string;
-    /** Optional service name for keychain entries */
-    serviceName?: string;
+  type: 'keychain';
+  /** Optional store ID (defaults to 'keychain-default') */
+  id?: string;
+  /** Optional service name for keychain entries */
+  serviceName?: string;
 }
 /**
  * Configuration for Nango-based credential storage (OAuth management)
  * Note: Using Nango requires the @nangohq/node package to be installed
  */
 interface NangoCredentialConfig {
-    type: 'nango';
-    /** Optional store ID (defaults to 'nango-default') */
-    id?: string;
-    /** Nango secret key (defaults to NANGO_SECRET_KEY env var) */
-    secretKey?: string;
-    /** Nango API URL (defaults to https://api.nango.dev) */
-    apiUrl?: string;
+  type: 'nango';
+  /** Optional store ID (defaults to 'nango-default') */
+  id?: string;
+  /** Nango secret key (defaults to NANGO_SECRET_KEY env var) */
+  secretKey?: string;
+  /** Nango API URL (defaults to https://api.nango.dev) */
+  apiUrl?: string;
 }
 /**
  * Configuration for custom credential provider
  */
 interface CustomCredentialConfig {
-    type: 'custom';
-    /** Custom credential store implementation */
-    store: CredentialStore;
+  type: 'custom';
+  /** Custom credential store implementation */
+  store: CredentialStore;
 }
 /**
  * Union type for all credential provider configurations
@@ -1396,59 +1406,59 @@ type CredentialProviderConfig = MemoryCredentialConfig | KeychainCredentialConfi
  * ```
  */
 declare class InkeepCredentialProvider implements CredentialStore {
-    private store;
-    constructor(config?: CredentialProviderConfig);
-    /**
-     * Create the appropriate store based on configuration
-     */
-    private createStore;
-    /**
-     * Create keychain store with dynamic import
-     */
-    private createKeychainStore;
-    /**
-     * Create Nango store with dynamic import
-     */
-    private createNangoStore;
-    get id(): string;
-    get type(): CredentialProviderType;
-    /**
-     * Get a credential by key
-     * @param key - The credential key
-     * @returns The credential value or null if not found
-     */
-    get(key: string): Promise<string | null>;
-    /**
-     * Set a credential
-     * @param key - The credential key
-     * @param value - The credential value
-     * @param metadata - Optional metadata
-     */
-    set(key: string, value: string, metadata?: Record<string, string>): Promise<void>;
-    /**
-     * Check if a credential exists
-     * @param key - The credential key
-     * @returns True if the credential exists
-     */
-    has(key: string): Promise<boolean>;
-    /**
-     * Delete a credential
-     * @param key - The credential key
-     * @returns True if the credential was deleted
-     */
-    delete(key: string): Promise<boolean>;
-    /**
-     * Check if the credential store is available and functional
-     * @returns Availability status
-     */
-    checkAvailability(): Promise<{
-        available: boolean;
-        reason?: string;
-    }>;
-    /**
-     * Get the underlying store (for advanced use cases)
-     */
-    getStore(): CredentialStore;
+  private store;
+  constructor(config?: CredentialProviderConfig);
+  /**
+   * Create the appropriate store based on configuration
+   */
+  private createStore;
+  /**
+   * Create keychain store with dynamic import
+   */
+  private createKeychainStore;
+  /**
+   * Create Nango store with dynamic import
+   */
+  private createNangoStore;
+  get id(): string;
+  get type(): CredentialProviderType;
+  /**
+   * Get a credential by key
+   * @param key - The credential key
+   * @returns The credential value or null if not found
+   */
+  get(key: string): Promise<string | null>;
+  /**
+   * Set a credential
+   * @param key - The credential key
+   * @param value - The credential value
+   * @param metadata - Optional metadata
+   */
+  set(key: string, value: string, metadata?: Record<string, string>): Promise<void>;
+  /**
+   * Check if a credential exists
+   * @param key - The credential key
+   * @returns True if the credential exists
+   */
+  has(key: string): Promise<boolean>;
+  /**
+   * Delete a credential
+   * @param key - The credential key
+   * @returns True if the credential was deleted
+   */
+  delete(key: string): Promise<boolean>;
+  /**
+   * Check if the credential store is available and functional
+   * @returns Availability status
+   */
+  checkAvailability(): Promise<{
+    available: boolean;
+    reason?: string;
+  }>;
+  /**
+   * Get the underlying store (for advanced use cases)
+   */
+  getStore(): CredentialStore;
 }
 /**
  * Factory function to create an InkeepCredentialProvider
@@ -1456,7 +1466,8 @@ declare class InkeepCredentialProvider implements CredentialStore {
  * @returns A new InkeepCredentialProvider instance
  */
 declare function createCredentialProvider(config?: CredentialProviderConfig): InkeepCredentialProvider;
-
+//#endregion
+//#region src/credential-ref.d.ts
 /**
  * Credential Reference System
  *
@@ -1469,8 +1480,8 @@ declare function createCredentialProvider(config?: CredentialProviderConfig): In
  * The actual credential will be resolved from the environment file at push time.
  */
 interface CredentialReference {
-    __type: 'credential-ref';
-    id: string;
+  __type: 'credential-ref';
+  id: string;
 }
 /**
  * Create a reference to a credential by its ID.
@@ -1498,53 +1509,46 @@ 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;
+  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 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;
+  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];
-
+type UnionMcpServerIds<T extends Record<string, any>> = { [K in keyof T]: ExtractMcpServerIds<T[K]> }[keyof T];
+//#endregion
+//#region src/environment-settings.d.ts
 interface EnvironmentSettingsConfig {
-    credentials?: {
-        [settingId: string]: CredentialReferenceApiInsert;
-    };
-    mcpServers?: {
-        [mcpServerId: string]: Tool;
-    };
+  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;
+  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 Full Project API
- * These functions make HTTP requests to the server instead of direct database calls
- */
-
+//#endregion
+//#region src/projectFullClient.d.ts
 /**
  * Create a full project via HTTP API
  */
@@ -1561,44 +1565,46 @@ declare function getFullProjectViaAPI(tenantId: string, apiUrl: string, projectI
  * Delete a full project via HTTP API
  */
 declare function deleteFullProjectViaAPI(tenantId: string, apiUrl: string, projectId: string, apiKey?: string): Promise<void>;
-
+//#endregion
+//#region src/runner.d.ts
 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;
-    }>;
+  /**
+   * 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;
-
+//#endregion
+//#region src/telemetry-provider.d.ts
 /**
  * TelemetryProvider - Abstraction for Telemetry/Observability
  *
@@ -1626,120 +1632,120 @@ declare const raceAgents: typeof Runner.raceAgents;
  * Span status codes
  */
 declare const SpanStatus: {
-    readonly OK: "ok";
-    readonly ERROR: "error";
-    readonly UNSET: "unset";
+  readonly OK: "ok";
+  readonly ERROR: "error";
+  readonly UNSET: "unset";
 };
 type SpanStatusType = (typeof SpanStatus)[keyof typeof SpanStatus];
 /**
  * Span interface for tracing
  */
 interface TelemetrySpan {
-    /** Set span attributes */
-    setAttributes(attributes: Record<string, unknown>): TelemetrySpan;
-    /** Set a single attribute */
-    setAttribute(key: string, value: unknown): TelemetrySpan;
-    /** Record an exception */
-    recordException(error: Error): TelemetrySpan;
-    /** Set span status */
-    setStatus(status: SpanStatusType, message?: string): TelemetrySpan;
-    /** Add an event to the span */
-    addEvent(name: string, attributes?: Record<string, unknown>): TelemetrySpan;
-    /** End the span */
-    end(): void;
-    /** Check if span is recording */
-    isRecording(): boolean;
-    /** Update span name */
-    updateName(name: string): TelemetrySpan;
+  /** Set span attributes */
+  setAttributes(attributes: Record<string, unknown>): TelemetrySpan;
+  /** Set a single attribute */
+  setAttribute(key: string, value: unknown): TelemetrySpan;
+  /** Record an exception */
+  recordException(error: Error): TelemetrySpan;
+  /** Set span status */
+  setStatus(status: SpanStatusType, message?: string): TelemetrySpan;
+  /** Add an event to the span */
+  addEvent(name: string, attributes?: Record<string, unknown>): TelemetrySpan;
+  /** End the span */
+  end(): void;
+  /** Check if span is recording */
+  isRecording(): boolean;
+  /** Update span name */
+  updateName(name: string): TelemetrySpan;
 }
 /**
  * Span options
  */
 interface SpanOptions {
-    /** Span attributes */
-    attributes?: Record<string, unknown>;
-    /** Parent span (for context propagation) */
-    parent?: TelemetrySpan;
+  /** Span attributes */
+  attributes?: Record<string, unknown>;
+  /** Parent span (for context propagation) */
+  parent?: TelemetrySpan;
 }
 /**
  * Tracer interface for creating spans
  */
 interface TelemetryTracer {
-    /** Start a new active span and execute callback */
-    startActiveSpan<T>(name: string, fn: (span: TelemetrySpan) => T): T;
-    startActiveSpan<T>(name: string, options: SpanOptions, fn: (span: TelemetrySpan) => T): T;
-    /** Start a new span without making it active */
-    startSpan(name: string, options?: SpanOptions): TelemetrySpan;
+  /** Start a new active span and execute callback */
+  startActiveSpan<T>(name: string, fn: (span: TelemetrySpan) => T): T;
+  startActiveSpan<T>(name: string, options: SpanOptions, fn: (span: TelemetrySpan) => T): T;
+  /** Start a new span without making it active */
+  startSpan(name: string, options?: SpanOptions): TelemetrySpan;
 }
 /**
  * Logger interface for structured logging
  */
 interface TelemetryLogger {
-    debug(message: string, context?: Record<string, unknown>): void;
-    info(message: string, context?: Record<string, unknown>): void;
-    warn(message: string, context?: Record<string, unknown>): void;
-    error(message: string, context?: Record<string, unknown>): void;
+  debug(message: string, context?: Record<string, unknown>): void;
+  info(message: string, context?: Record<string, unknown>): void;
+  warn(message: string, context?: Record<string, unknown>): void;
+  error(message: string, context?: Record<string, unknown>): void;
 }
 /**
  * Metrics interface for recording measurements
  */
 interface TelemetryMetrics {
-    /** Increment a counter */
-    increment(name: string, value?: number, attributes?: Record<string, unknown>): void;
-    /** Record a gauge value */
-    gauge(name: string, value: number, attributes?: Record<string, unknown>): void;
-    /** Record a histogram value */
-    histogram(name: string, value: number, attributes?: Record<string, unknown>): void;
+  /** Increment a counter */
+  increment(name: string, value?: number, attributes?: Record<string, unknown>): void;
+  /** Record a gauge value */
+  gauge(name: string, value: number, attributes?: Record<string, unknown>): void;
+  /** Record a histogram value */
+  histogram(name: string, value: number, attributes?: Record<string, unknown>): void;
 }
 /**
  * Main telemetry provider interface
  */
 interface TelemetryProvider {
-    /** Get a tracer for creating spans */
-    getTracer(name: string, version?: string): TelemetryTracer;
-    /** Get a logger for structured logging */
-    getLogger(name: string): TelemetryLogger;
-    /** Get metrics for recording measurements */
-    getMetrics(name: string): TelemetryMetrics;
-    /** Shutdown the telemetry provider */
-    shutdown(): Promise<void>;
-    /** Check if telemetry is enabled */
-    isEnabled(): boolean;
+  /** Get a tracer for creating spans */
+  getTracer(name: string, version?: string): TelemetryTracer;
+  /** Get a logger for structured logging */
+  getLogger(name: string): TelemetryLogger;
+  /** Get metrics for recording measurements */
+  getMetrics(name: string): TelemetryMetrics;
+  /** Shutdown the telemetry provider */
+  shutdown(): Promise<void>;
+  /** Check if telemetry is enabled */
+  isEnabled(): boolean;
 }
 /**
  * Configuration for telemetry provider
  */
 interface TelemetryConfig {
-    /** Whether telemetry is enabled (default: false) */
-    enabled?: boolean;
-    /** Service name for identifying the source */
-    serviceName?: string;
-    /** Service version */
-    serviceVersion?: string;
-    /** Custom provider implementation */
-    provider?: TelemetryProvider;
+  /** Whether telemetry is enabled (default: false) */
+  enabled?: boolean;
+  /** Service name for identifying the source */
+  serviceName?: string;
+  /** Service version */
+  serviceVersion?: string;
+  /** Custom provider implementation */
+  provider?: TelemetryProvider;
 }
 /**
  * No-op telemetry provider (default)
  */
 declare class NoOpTelemetryProvider implements TelemetryProvider {
-    getTracer(_name: string, _version?: string): TelemetryTracer;
-    getLogger(_name: string): TelemetryLogger;
-    getMetrics(_name: string): TelemetryMetrics;
-    shutdown(): Promise<void>;
-    isEnabled(): boolean;
+  getTracer(_name: string, _version?: string): TelemetryTracer;
+  getLogger(_name: string): TelemetryLogger;
+  getMetrics(_name: string): TelemetryMetrics;
+  shutdown(): Promise<void>;
+  isEnabled(): boolean;
 }
 /**
  * Console-based telemetry provider for development/debugging
  */
 declare class ConsoleTelemetryProvider implements TelemetryProvider {
-    private serviceName;
-    constructor(serviceName?: string);
-    getTracer(name: string, _version?: string): TelemetryTracer;
-    getLogger(name: string): TelemetryLogger;
-    getMetrics(name: string): TelemetryMetrics;
-    shutdown(): Promise<void>;
-    isEnabled(): boolean;
+  private serviceName;
+  constructor(serviceName?: string);
+  getTracer(name: string, _version?: string): TelemetryTracer;
+  getLogger(name: string): TelemetryLogger;
+  getMetrics(name: string): TelemetryMetrics;
+  shutdown(): Promise<void>;
+  isEnabled(): boolean;
 }
 /**
  * InkeepTelemetryProvider - Main telemetry management class
@@ -1748,36 +1754,36 @@ declare class ConsoleTelemetryProvider implements TelemetryProvider {
  * Telemetry is OPT-IN - by default, a no-op provider is used.
  */
 declare class InkeepTelemetryProvider {
-    private provider;
-    constructor(config?: TelemetryConfig);
-    /**
-     * Get a tracer for creating spans
-     */
-    getTracer(name: string, version?: string): TelemetryTracer;
-    /**
-     * Get a logger for structured logging
-     */
-    getLogger(name: string): TelemetryLogger;
-    /**
-     * Get metrics recorder
-     */
-    getMetrics(name: string): TelemetryMetrics;
-    /**
-     * Check if telemetry is enabled
-     */
-    isEnabled(): boolean;
-    /**
-     * Shutdown the provider
-     */
-    shutdown(): Promise<void>;
-    /**
-     * Get the underlying provider
-     */
-    getProvider(): TelemetryProvider;
-    /**
-     * Set as the global telemetry provider
-     */
-    setAsGlobal(): void;
+  private provider;
+  constructor(config?: TelemetryConfig);
+  /**
+   * Get a tracer for creating spans
+   */
+  getTracer(name: string, version?: string): TelemetryTracer;
+  /**
+   * Get a logger for structured logging
+   */
+  getLogger(name: string): TelemetryLogger;
+  /**
+   * Get metrics recorder
+   */
+  getMetrics(name: string): TelemetryMetrics;
+  /**
+   * Check if telemetry is enabled
+   */
+  isEnabled(): boolean;
+  /**
+   * Shutdown the provider
+   */
+  shutdown(): Promise<void>;
+  /**
+   * Get the underlying provider
+   */
+  getProvider(): TelemetryProvider;
+  /**
+   * Set as the global telemetry provider
+   */
+  setAsGlobal(): void;
 }
 /**
  * Get the global telemetry provider
@@ -1799,14 +1805,14 @@ declare function createConsoleTelemetryProvider(serviceName?: string): InkeepTel
  * Configuration for OpenTelemetry provider
  */
 interface OpenTelemetryConfig {
-    /** Service name */
-    serviceName: string;
-    /** Service version */
-    serviceVersion?: string;
-    /** OTLP endpoint URL */
-    endpoint?: string;
-    /** Additional resource attributes */
-    resourceAttributes?: Record<string, string>;
+  /** Service name */
+  serviceName: string;
+  /** Service version */
+  serviceVersion?: string;
+  /** OTLP endpoint URL */
+  endpoint?: string;
+  /** Additional resource attributes */
+  resourceAttributes?: Record<string, string>;
 }
 /**
  * Create an OpenTelemetry-based provider
@@ -1814,5 +1820,6 @@ interface OpenTelemetryConfig {
  * Note: Requires @opentelemetry packages to be installed
  */
 declare function createOpenTelemetryProvider(config: OpenTelemetryConfig): Promise<InkeepTelemetryProvider>;
-
-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, ConsoleTelemetryProvider, type CredentialProviderConfig, type CredentialProviderType, type CredentialReference, type CredentialStore, type CustomCredentialConfig, DataComponent, type DataComponentInterface, type DataComponentWithZodProps, ExternalAgent, type ExternalAgentInterface, type ExtractCredentialIds, type FetchDefinitionConfig, FunctionTool, type GenerateOptions, InkeepCredentialProvider, InkeepTelemetryProvider, type KeychainCredentialConfig, type MCPToolConfig, MaxTurnsExceededError, type MemoryCredentialConfig, type Message, type MessageInput, type NangoCredentialConfig, NoOpTelemetryProvider, type OpenTelemetryConfig, Project, type RequestSchemaConfig, type RequestSchemaDefinition, type RunResult, Runner, type ServerConfig, type SpanOptions, SpanStatus, type SpanStatusType, StatusComponent, type StatusComponentInterface, type StreamEvent, type StreamResponse, SubAgent, type SubAgentCanUseType, type SubAgentConfig, type SubAgentInterface, type SystemMessage, type TelemetryConfig, type TelemetryLogger, type TelemetryMetrics, type TelemetryProvider, type TelemetrySpan, type TelemetryTracer, Tool, type ToolCall, type ToolConfig, ToolExecutionError, type ToolMessage, type ToolResult, type TransferConfig, TransferError, type UnionCredentialIds, type UserMessage, agent, agentMcp, artifactComponent, createConsoleTelemetryProvider, createCredentialProvider, createEnvironmentSettings, createFullProjectViaAPI, createNoOpTelemetryProvider, createOpenTelemetryProvider, credential, credentialRef, dataComponent, deleteFullProjectViaAPI, externalAgent, externalAgents, functionTool, getFullProjectViaAPI, getGlobalTelemetryProvider, isCredentialReference, mcpServer, mcpTool, project, raceAgents, registerEnvironmentSettings, run, setGlobalTelemetryProvider, statusComponent, stream, subAgent, type subAgentExternalAgentInterface, type subAgentTeamAgentInterface, transfer, updateFullProjectViaAPI };
+//#endregion
+export { ANTHROPIC_MODELS, AgentConfig, AgentError, AgentInterface, AgentResponse, AgentTool, AllDelegateInputInterface, AllDelegateOutputInterface, ArtifactComponent, type ArtifactComponentInterface, ArtifactComponentWithZodProps, AssistantMessage, BuilderAgentConfig, BuilderRelationConfig, BuilderToolConfig, ConsoleTelemetryProvider, type CredentialProviderConfig, type CredentialProviderType, type CredentialReference, type CredentialStore, type CustomCredentialConfig, DataComponent, type DataComponentInterface, DataComponentWithZodProps, ExternalAgent, ExternalAgentInterface, type ExtractCredentialIds, FetchDefinitionConfig, FunctionTool, type FunctionToolConfig, GOOGLE_MODELS, GenerateOptions, InkeepCredentialProvider, InkeepTelemetryProvider, type KeychainCredentialConfig, MCPToolConfig, MaxTurnsExceededError, type MemoryCredentialConfig, Message, MessageInput, type ModelSettings, type NangoCredentialConfig, NoOpTelemetryProvider, OPENAI_MODELS, type OpenTelemetryConfig, Project, RequestSchemaConfig, RequestSchemaDefinition, RunResult, Runner, ServerConfig, type SpanOptions, SpanStatus, type SpanStatusType, StatusComponent, type StatusComponentInterface, StreamEvent, StreamResponse, SubAgent, SubAgentCanUseType, SubAgentConfig, SubAgentInterface, SystemMessage, type TelemetryConfig, type TelemetryLogger, type TelemetryMetrics, type TelemetryProvider, type TelemetrySpan, type TelemetryTracer, Tool, ToolCall, ToolConfig, ToolExecutionError, ToolMessage, ToolResult, TransferConfig, TransferError, type UnionCredentialIds, UserMessage, agent, agentMcp, artifactComponent, createConsoleTelemetryProvider, createCredentialProvider, createEnvironmentSettings, createFullProjectViaAPI, createNoOpTelemetryProvider, createOpenTelemetryProvider, credential, credentialRef, dataComponent, deleteFullProjectViaAPI, externalAgent, externalAgents, functionTool, getFullProjectViaAPI, getGlobalTelemetryProvider, isCredentialReference, mcpServer, mcpTool, project, raceAgents, registerEnvironmentSettings, run, setGlobalTelemetryProvider, statusComponent, stream, subAgent, subAgentExternalAgentInterface, subAgentTeamAgentInterface, transfer, updateFullProjectViaAPI };
+//# sourceMappingURL=index.d.cts.map