@inkeep/agents-sdk 0.0.0-dev-20260117173149 → 0.0.0-dev-20260117201141

package/dist/builderFunctions.d.ts

@@ -13,271 +13,260 @@ import { CredentialReferenceApiInsert, MCPToolConfig } from "@inkeep/agents-core
 //#region src/builderFunctions.d.ts
 
 /**
- * Helper function to create agent - OpenAI style
- */
+* 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
- *     })
- *   ]
- * });
- * ```
- */
+* 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'
- * });
- * ```
- */
+* 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): {
-  name: string;
-  id: string;
-  credentialStoreId: string;
-  type: "memory" | "keychain" | "nango";
-  createdAt?: string | undefined;
-  updatedAt?: string | undefined;
-  userId?: string | null | undefined;
-  toolId?: string | null | undefined;
-  retrievalParams?: Record<string, unknown> | null | undefined;
-  createdBy?: string | null | undefined;
-};
+* 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): CredentialReferenceApiInsert;
 /**
- * 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
- *   })
- * });
- * ```
- */
+* 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' }
- * });
- * ```
- */
+* 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): 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' }
- *     }
- *   }
- * });
- * ```
- */
+* 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'
- *   }
- * });
- * ```
- */
+* 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'])
- *   })
- * });
- * ```
- */
+* 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$1;
 /**
- * (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
- */
+* (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}`);
- *     }
- *   }
- * });
- * ```
- */
+* 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
 export { agent, agentMcp, artifactComponent, credential, dataComponent, functionTool, mcpServer, mcpTool, project, statusComponent, subAgent };

package/dist/builderFunctionsExperimental.d.ts

@@ -1,22 +1,22 @@
 //#region src/builderFunctionsExperimental.d.ts
 /**
- * Creates an agent relation configuration.
- *
- * Relations define how agents can interact with each other.
- * Transfer relations allow transfers, while delegate relations
- * allow temporary task delegation.
- *
- * @param targetAgent - The ID of the target agent
- * @param relationType - The type of relation (transfer or delegate)
- * @returns An agent relation configuration
- *
- * @example
- * ```typescript
- * const transferRelation = agentRelation('support-agent', 'transfer');
- * const delegateRelation = agentRelation('specialist-agent', 'delegate');
- * ```
- */
-declare function agentRelation(targetAgent: string, relationType?: 'transfer' | 'delegate'): {
+* Creates an agent relation configuration.
+*
+* Relations define how agents can interact with each other.
+* Transfer relations allow transfers, while delegate relations
+* allow temporary task delegation.
+*
+* @param targetAgent - The ID of the target agent
+* @param relationType - The type of relation (transfer or delegate)
+* @returns An agent relation configuration
+*
+* @example
+* ```typescript
+* const transferRelation = agentRelation('support-agent', 'transfer');
+* const delegateRelation = agentRelation('specialist-agent', 'delegate');
+* ```
+*/
+declare function agentRelation(targetAgent: string, relationType?: "transfer" | "delegate"): {
   targetAgent: string;
   relationType: "transfer" | "delegate";
 };