@inkeep/agents-sdk 0.41.2 → 0.42.0

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";
 };

package/dist/builders.d.ts

@@ -7,18 +7,18 @@ import { z } from "zod";
 //#region src/builders.d.ts
 
 /**
- * Function signature for tool execution
- * @template TParams - Type of input parameters
- * @template TResult - Type of return value
- */
+* Function signature for tool execution
+* @template TParams - Type of input parameters
+* @template TResult - Type of return value
+*/
 type ToolExecuteFunction<TParams = unknown, TResult = unknown> = (params: TParams) => Promise<TResult>;
 /**
- * Function signature for transfer conditions
- */
+* Function signature for transfer conditions
+*/
 type TransferConditionFunction = (context: unknown) => boolean;
 /**
- * Configuration for MCP server builders
- */
+* Configuration for MCP server builders
+*/
 interface MCPServerConfig {
   name: string;
   description: string;
@@ -26,14 +26,14 @@ interface MCPServerConfig {
   id?: string;
   parameters?: Record<string, z.ZodJSONSchema>;
   credential?: CredentialReferenceApiInsert;
-  transport?: 'streamable_http' | 'sse';
+  transport?: "streamable_http" | "sse";
   activeTools?: string[];
   headers?: Record<string, string>;
   imageUrl?: string;
 }
 /**
- * Configuration for component builders
- */
+* Configuration for component builders
+*/
 interface ComponentConfig {
   id?: string;
   name: string;
@@ -55,12 +55,12 @@ interface StatusComponentConfig {
   detailsSchema?: Record<string, unknown> | z.ZodObject<any>;
 }
 /**
- * Schema for transfer configuration (excluding function properties)
- */
-declare const TransferConfigSchema: z.ZodObject<{
-  agent: z.ZodCustom<SubAgent, SubAgent>;
-  description: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
+* Schema for transfer configuration (excluding function properties)
+*/
+declare const TransferConfigSchema: z.ZodType<{
+  agent: SubAgent;
+  description?: string;
+}>;
 type AgentMcpConfig = {
   server: Tool;
   selectedTools?: string[];
@@ -68,44 +68,44 @@ type AgentMcpConfig = {
   toolPolicies?: Record<string, ToolPolicy>;
 };
 /**
- * Input configuration for MCP tool customization
- * Supports flexible tool selection with per-tool policies
- */
+* 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
-   */
+  * 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
- * );
- * ```
- */
+* 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
 export { AgentMcpConfig, AgentMcpConfigInput, ArtifactComponentConfig, ComponentConfig, DataComponentConfig, MCPServerConfig, StatusComponentConfig, ToolExecuteFunction, TransferConditionFunction, TransferConfigSchema, transfer };

package/dist/credential-provider.d.ts

@@ -1,29 +1,29 @@
 //#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'
- * })
- * ```
- */
+* 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
- */
+* 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;
@@ -44,33 +44,33 @@ interface CredentialStore {
   }>;
 }
 /**
- * Supported credential provider types
- */
-type CredentialProviderType = 'memory' | 'keychain' | 'nango' | 'custom';
+* Supported credential provider types
+*/
+type CredentialProviderType = "memory" | "keychain" | "nango" | "custom";
 /**
- * Configuration for memory-based credential storage
- */
+* Configuration for memory-based credential storage
+*/
 interface MemoryCredentialConfig {
-  type: 'memory';
+  type: "memory";
   /** Optional store ID (defaults to 'memory-default') */
   id?: string;
 }
 /**
- * Configuration for keychain-based credential storage
- */
+* Configuration for keychain-based credential storage
+*/
 interface KeychainCredentialConfig {
-  type: 'keychain';
+  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
- */
+* Configuration for Nango-based credential storage (OAuth management)
+* Note: Using Nango requires the @nangohq/node package to be installed
+*/
 interface NangoCredentialConfig {
-  type: 'nango';
+  type: "nango";
   /** Optional store ID (defaults to 'nango-default') */
   id?: string;
   /** Nango secret key (defaults to NANGO_SECRET_KEY env var) */
@@ -79,98 +79,98 @@ interface NangoCredentialConfig {
   apiUrl?: string;
 }
 /**
- * Configuration for custom credential provider
- */
+* Configuration for custom credential provider
+*/
 interface CustomCredentialConfig {
-  type: 'custom';
+  type: "custom";
   /** Custom credential store implementation */
   store: CredentialStore;
 }
 /**
- * Union type for all credential provider configurations
- */
+* 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'
- * ```
- */
+* 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
-   */
+  * Create the appropriate store based on configuration
+  */
   private createStore;
   /**
-   * Create keychain store with dynamic import
-   */
+  * Create keychain store with dynamic import
+  */
   private createKeychainStore;
   /**
-   * Create Nango store with dynamic import
-   */
+  * 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 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 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
-   */
+  * 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 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
-   */
+  * 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)
-   */
+  * 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
- */
+* Factory function to create an InkeepCredentialProvider
+* @param config - Configuration options
+* @returns A new InkeepCredentialProvider instance
+*/
 declare function createCredentialProvider(config?: CredentialProviderConfig): InkeepCredentialProvider;
 //#endregion
 export { CredentialProviderConfig, CredentialProviderType, CredentialStore, CustomCredentialConfig, InkeepCredentialProvider, KeychainCredentialConfig, MemoryCredentialConfig, NangoCredentialConfig, createCredentialProvider };

package/dist/credential-ref.d.ts

@@ -1,60 +1,60 @@
 //#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.
- */
+* 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';
+  __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,
- *   // ...
- * });
- * ```
- */
+* 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
- */
+* 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 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 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 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 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
 export { CredentialReference, ExtractCredentialIds, ExtractMcpServerIds, UnionCredentialIds, UnionMcpServerIds, credentialRef, isCredentialReference };

package/dist/data-component.d.ts

@@ -2,7 +2,7 @@ import { DataComponentInsert } from "@inkeep/agents-core";
 import { z } from "zod";
 
 //#region src/data-component.d.ts
-type DataComponentConfigWithZod = Omit<DataComponentInsert, 'tenantId' | 'projectId' | 'props' | 'render'> & {
+type DataComponentConfigWithZod = Omit<DataComponentInsert, "tenantId" | "projectId" | "props" | "render"> & {
   props?: Record<string, unknown> | z.ZodObject<any> | null;
   render?: {
     component: string;
@@ -10,16 +10,16 @@ type DataComponentConfigWithZod = Omit<DataComponentInsert, 'tenantId' | 'projec
   } | null;
 };
 interface DataComponentInterface {
-  config: Omit<DataComponentInsert, 'tenantId' | 'projectId'>;
+  config: Omit<DataComponentInsert, "tenantId" | "projectId">;
   init(): Promise<void>;
-  getId(): DataComponentInsert['id'];
-  getName(): DataComponentInsert['name'];
-  getDescription(): DataComponentInsert['description'];
-  getProps(): DataComponentInsert['props'];
+  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'>;
+  config: Omit<DataComponentInsert, "tenantId" | "projectId">;
   private baseURL;
   private tenantId;
   private projectId;
@@ -30,8 +30,8 @@ declare class DataComponent implements DataComponentInterface {
   getId(): string;
   getName(): string;
   getDescription(): string;
-  getProps(): DataComponentInsert['props'];
-  getRender(): DataComponentInsert['render'];
+  getProps(): DataComponentInsert["props"];
+  getRender(): DataComponentInsert["render"];
   init(): Promise<void>;
   private upsertDataComponent;
 }

package/dist/data-component.js

@@ -73,7 +73,7 @@ var DataComponent = class {
 			render: this.config.render
 		};
 		logger.info({ dataComponentData }, "dataComponentData for create/update");
-		const updateResponse = await fetch(`${this.baseURL}/tenants/${this.tenantId}/projects/${this.projectId}/data-components/${this.getId()}`, {
+		const updateResponse = await fetch(`${this.baseURL}/manage/tenants/${this.tenantId}/projects/${this.projectId}/data-components/${this.getId()}`, {
 			method: "PUT",
 			headers: { "Content-Type": "application/json" },
 			body: JSON.stringify(dataComponentData)
@@ -88,7 +88,7 @@ var DataComponent = class {
 		}
 		if (updateResponse.status === 404) {
 			logger.info({ dataComponentId: this.getId() }, "DataComponent not found, creating new data component");
-			const createResponse = await fetch(`${this.baseURL}/tenants/${this.tenantId}/projects/${this.projectId}/data-components`, {
+			const createResponse = await fetch(`${this.baseURL}/manage/tenants/${this.tenantId}/projects/${this.projectId}/data-components`, {
 				method: "POST",
 				headers: { "Content-Type": "application/json" },
 				body: JSON.stringify(dataComponentData)

package/dist/environment-settings.d.ts

@@ -12,16 +12,16 @@ interface EnvironmentSettingsConfig {
   };
 }
 /**
- * Create a setting helper with TypeScript autocomplete
- */
+* 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
- */
+* Create type-safe environment configurations
+*/
 declare function registerEnvironmentSettings<T extends EnvironmentSettingsConfig>(config: T): T;
 //#endregion
 export { type ExtractCredentialIds, type ExtractMcpServerIds, type UnionCredentialIds, type UnionMcpServerIds, createEnvironmentSettings, registerEnvironmentSettings };