@inkeep/agents-sdk 0.39.4 → 0.40.0

package/dist/index.d.cts

@@ -1,1825 +0,0 @@
-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;
-};
-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;
-}
-//#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;
-}
-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;
-}
-//#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.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
- */
-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
-   * - 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.
- *
- * 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;
-//#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;
-};
-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;
-}
-//#endregion
-//#region src/external-agent.d.ts
-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>;
-//#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>;
-}
-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;
-  };
-}
-//#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>;
-}
-/**
- * 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[];
-}
-//#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;
-}
-//#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[];
-}
-/**
- * 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;
-}
-//#endregion
-//#region src/status-component.d.ts
-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'];
-}
-//#endregion
-//#region src/builderFunctions.d.ts
-/**
- * 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: "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.
- *
- * 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;
-//#endregion
-//#region src/credential-provider.d.ts
-/**
- * InkeepCredentialProvider - Abstraction for Credential Management
- *
- * This module provides a clean abstraction over credential provider implementations.
- * Cloud customers can use this without needing to know about or install internal
- * dependencies like Nango.
- *
- * @example
- * ```typescript
- * // Simple usage with environment variables (default)
- * import { InkeepCredentialProvider } from '@inkeep/agents-sdk'
- *
- * const credentials = new InkeepCredentialProvider()
- *
- * // With custom configuration
- * const credentials = new InkeepCredentialProvider({
- *   type: 'memory',
- *   id: 'my-store'
- * })
- * ```
- */
-/**
- * Base interface for all credential stores
- * 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;
-  }>;
-}
-/**
- * Supported credential provider types
- */
-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;
-}
-/**
- * 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;
-}
-/**
- * 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;
-}
-/**
- * Configuration for custom credential provider
- */
-interface CustomCredentialConfig {
-  type: 'custom';
-  /** Custom credential store implementation */
-  store: CredentialStore;
-}
-/**
- * Union type for all credential provider configurations
- */
-type CredentialProviderConfig = MemoryCredentialConfig | KeychainCredentialConfig | NangoCredentialConfig | CustomCredentialConfig;
-/**
- * InkeepCredentialProvider - Unified credential management for Inkeep SDK
- *
- * Provides a clean abstraction over various credential storage backends.
- * Cloud customers can use simple memory-based storage, while advanced
- * users can integrate with OAuth providers like Nango.
- *
- * @example
- * ```typescript
- * // Default memory-based storage
- * const provider = new InkeepCredentialProvider()
- *
- * // Store and retrieve credentials
- * await provider.set('my-api-key', 'secret-value')
- * const key = await provider.get('my-api-key')
- *
- * // Use environment variables automatically
- * process.env.MY_TOKEN = 'env-token'
- * const token = await provider.get('MY_TOKEN') // Returns 'env-token'
- * ```
- */
-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;
-}
-/**
- * Factory function to create an InkeepCredentialProvider
- * @param config - Configuration options
- * @returns A new InkeepCredentialProvider instance
- */
-declare function createCredentialProvider(config?: CredentialProviderConfig): InkeepCredentialProvider;
-//#endregion
-//#region src/credential-ref.d.ts
-/**
- * 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];
-//#endregion
-//#region src/environment-settings.d.ts
-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;
-//#endregion
-//#region src/projectFullClient.d.ts
-/**
- * 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>;
-//#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;
-  }>;
-}
-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
- *
- * This module provides a clean abstraction over telemetry implementations.
- * Cloud customers can use this without needing to install or configure
- * OpenTelemetry or Signoz directly.
- *
- * Telemetry is OPT-IN - if not configured, a no-op provider is used.
- *
- * @example
- * ```typescript
- * // Opt-in to telemetry with default console logger
- * import { InkeepTelemetryProvider, createConsoleTelemetryProvider } from '@inkeep/agents-sdk'
- *
- * const telemetry = createConsoleTelemetryProvider()
- *
- * // Or with OpenTelemetry (requires @opentelemetry packages)
- * const telemetry = createOpenTelemetryProvider({
- *   serviceName: 'my-agent',
- *   endpoint: 'http://localhost:4318'
- * })
- * ```
- */
-/**
- * Span status codes
- */
-declare const SpanStatus: {
-  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;
-}
-/**
- * Span options
- */
-interface SpanOptions {
-  /** 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;
-}
-/**
- * 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;
-}
-/**
- * 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;
-}
-/**
- * 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;
-}
-/**
- * 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;
-}
-/**
- * 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;
-}
-/**
- * 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;
-}
-/**
- * InkeepTelemetryProvider - Main telemetry management class
- *
- * Provides a unified interface for telemetry across the SDK.
- * 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;
-}
-/**
- * Get the global telemetry provider
- */
-declare function getGlobalTelemetryProvider(): TelemetryProvider;
-/**
- * Set the global telemetry provider
- */
-declare function setGlobalTelemetryProvider(provider: TelemetryProvider): void;
-/**
- * Create a no-op telemetry provider (default, does nothing)
- */
-declare function createNoOpTelemetryProvider(): InkeepTelemetryProvider;
-/**
- * Create a console-based telemetry provider for development
- */
-declare function createConsoleTelemetryProvider(serviceName?: string): InkeepTelemetryProvider;
-/**
- * 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>;
-}
-/**
- * Create an OpenTelemetry-based provider
- *
- * Note: Requires @opentelemetry packages to be installed
- */
-declare function createOpenTelemetryProvider(config: OpenTelemetryConfig): Promise<InkeepTelemetryProvider>;
-//#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