@inkeep/agents-sdk 0.39.4 → 0.40.0

package/dist/environment-settings.js

@@ -0,0 +1,41 @@
+//#region src/environment-settings.ts
+/**
+* Create a setting helper with TypeScript autocomplete
+*/
+function createEnvironmentSettings(environments) {
+	return {
+		getEnvironmentCredential: (key) => {
+			const currentEnv = process.env.INKEEP_ENV || "development";
+			const env = environments[currentEnv];
+			if (!env) throw new Error(`Environment '${currentEnv}' not found. Available: ${Object.keys(environments).join(", ")}`);
+			const credential = env.credentials?.[key];
+			if (!credential) throw new Error(`Credential '${String(key)}' not found in environment '${currentEnv}'`);
+			return credential;
+		},
+		getEnvironmentMcp: (key) => {
+			const currentEnv = process.env.INKEEP_ENV || "development";
+			const env = environments[currentEnv];
+			if (!env) throw new Error(`Environment '${currentEnv}' not found. Available: ${Object.keys(environments).join(", ")}`);
+			const mcpServer = env.mcpServers?.[key];
+			if (!mcpServer) throw new Error(`MCP Server '${String(key)}' not found in environment '${currentEnv}'`);
+			return mcpServer;
+		},
+		getEnvironmentSetting: (key) => {
+			const currentEnv = process.env.INKEEP_ENV || "development";
+			const env = environments[currentEnv];
+			if (!env) throw new Error(`Environment '${currentEnv}' not found. Available: ${Object.keys(environments).join(", ")}`);
+			const credential = env.credentials?.[key];
+			if (!credential) throw new Error(`Credential '${String(key)}' not found in environment '${currentEnv}'`);
+			return credential;
+		}
+	};
+}
+/**
+* Create type-safe environment configurations
+*/
+function registerEnvironmentSettings(config) {
+	return config;
+}
+
+//#endregion
+export { createEnvironmentSettings, registerEnvironmentSettings };

package/dist/external-agent.d.ts

@@ -0,0 +1,64 @@
+import { ExternalAgentInterface, subAgentExternalAgentInterface } from "./types.js";
+import { CredentialReferenceApiInsert } from "@inkeep/agents-core";
+
+//#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>;
+/**
+ * Helper to batch initialize external agents
+ */
+declare function initializeExternalAgents(builders: ExternalAgent[]): Promise<void>;
+//#endregion
+export { ExternalAgent, ExternalAgentConfig, externalAgent, externalAgents, initializeExternalAgents };

package/dist/external-agent.js

@@ -0,0 +1,156 @@
+import { getLogger } from "@inkeep/agents-core";
+
+//#region src/external-agent.ts
+const logger = getLogger("external-agent-builder");
+var ExternalAgent = class {
+	config;
+	type = "external";
+	initialized = false;
+	tenantId;
+	projectId;
+	baseURL;
+	constructor(config) {
+		this.config = {
+			...config,
+			type: "external"
+		};
+		this.tenantId = "default";
+		this.projectId = "default";
+		this.baseURL = this.config.baseUrl;
+		logger.debug({
+			externalAgentName: this.config.name,
+			baseUrl: this.config.baseUrl,
+			tenantId: this.tenantId
+		}, "External Agent constructor initialized");
+	}
+	/**
+	* Initialize the external agent by upserting it in the database
+	*/
+	async init() {
+		if (this.initialized) return;
+		try {
+			await this.upsertExternalAgent();
+			logger.info({ externalSubAgentId: this.getId() }, "External agent initialized successfully");
+			this.initialized = true;
+		} catch (error) {
+			logger.error({
+				externalSubAgentId: this.getId(),
+				error: error instanceof Error ? error.message : "Unknown error"
+			}, "Failed to initialize external agent");
+			throw error;
+		}
+	}
+	setContext(tenantId, projectId) {
+		this.tenantId = tenantId;
+		this.projectId = projectId;
+	}
+	getId() {
+		return this.config.id;
+	}
+	with(options) {
+		return {
+			externalAgent: this,
+			headers: options.headers
+		};
+	}
+	async upsertExternalAgent() {
+		const externalAgentData = {
+			id: this.getId(),
+			name: this.config.name,
+			description: this.config.description,
+			baseUrl: this.config.baseUrl,
+			credentialReferenceId: this.config.credentialReference?.id || void 0
+		};
+		const updateResponse = await fetch(`${this.baseURL}/tenants/${this.tenantId}/projects/${this.projectId}/external-agents/${this.getId()}`, {
+			method: "PUT",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify(externalAgentData)
+		});
+		if (updateResponse.ok) {
+			logger.info({ externalSubAgentId: this.getId() }, "External agent updated successfully");
+			return;
+		}
+		if (updateResponse.status === 404) {
+			logger.info({ externalSubAgentId: this.getId() }, "External agent not found, creating new external agent");
+			const createResponse = await fetch(`${this.baseURL}/tenants/${this.tenantId}/projects/${this.projectId}/external-agents`, {
+				method: "POST",
+				headers: { "Content-Type": "application/json" },
+				body: JSON.stringify(externalAgentData)
+			});
+			if (!createResponse.ok) {
+				const errorText$1 = await createResponse.text().catch(() => "Unknown error");
+				throw new Error(`Failed to create external agent: ${createResponse.status} ${createResponse.statusText} - ${errorText$1}`);
+			}
+			logger.info({ externalSubAgentId: this.getId() }, "External agent created successfully");
+			return;
+		}
+		const errorText = await updateResponse.text().catch(() => "Unknown error");
+		throw new Error(`Failed to update external agent: ${updateResponse.status} ${updateResponse.statusText} - ${errorText}`);
+	}
+	/**
+	* Get the external agent configuration
+	*/
+	getConfig() {
+		return { ...this.config };
+	}
+	/**
+	* Get the external agent name
+	*/
+	getName() {
+		return this.config.name;
+	}
+	/**
+	* Get the external agent base URL
+	*/
+	getBaseUrl() {
+		return this.config.baseUrl;
+	}
+	/**
+	* Get the tenant ID
+	*/
+	getTenantId() {
+		return this.tenantId;
+	}
+	getDescription() {
+		return this.config.description || "";
+	}
+	getCredentialReferenceId() {
+		return this.config.credentialReference?.id || void 0;
+	}
+	getCredentialReference() {
+		return this.config.credentialReference || void 0;
+	}
+};
+/**
+* Factory function to create external agents - follows the same pattern as agent()
+*/
+function externalAgent(config) {
+	return new ExternalAgent(config);
+}
+/**
+* Helper function to create multiple external agents
+*/
+function externalAgents(configs) {
+	const builders = {};
+	for (const [name, config] of Object.entries(configs)) builders[name] = externalAgent(config);
+	return builders;
+}
+/**
+* Helper to batch initialize external agents
+*/
+async function initializeExternalAgents(builders) {
+	logger.info({ count: builders.length }, "Batch initializing external agents");
+	const initPromises = builders.map(async (builder) => {
+		return await builder.init();
+	});
+	try {
+		await Promise.all(initPromises);
+		logger.info({ count: builders.length }, "All external agents initialized successfully");
+	} catch (error) {
+		logger.error({ error: error instanceof Error ? error.message : "Unknown error" }, "Failed to initialize some external agents");
+		throw error;
+	}
+}
+
+//#endregion
+export { ExternalAgent, externalAgent, externalAgents, initializeExternalAgents };

package/dist/function-tool.d.ts

@@ -0,0 +1,37 @@
+import { FunctionToolConfig } from "./types.js";
+
+//#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
+export { FunctionTool, FunctionToolInterface };

package/dist/function-tool.js

@@ -0,0 +1,66 @@
+import { generateIdFromName } from "./utils/generateIdFromName.js";
+import { getFunctionToolDeps } from "./utils/getFunctionToolDeps.js";
+import { getLogger } from "@inkeep/agents-core";
+
+//#region src/function-tool.ts
+const logger = getLogger("function-tool");
+var FunctionTool = class {
+	config;
+	id;
+	constructor(config) {
+		this.config = config;
+		this.id = generateIdFromName(config.name);
+		if (!config.dependencies) {
+			const executeCode = typeof config.execute === "string" ? config.execute : config.execute.toString();
+			const deps = getFunctionToolDeps(config.name, executeCode);
+			for (const dep in deps) if (deps[dep] === false) {
+				delete deps[dep];
+				throw new Error(`Dependency \x1b[1;32m${dep}\x1b[0m used in function tool \x1b[1;32m${config.name}\x1b[0m is neither installed nor in dependencies object.`);
+			}
+			this.config.dependencies = deps;
+		}
+		logger.info({
+			id: this.id,
+			name: config.name
+		}, "FunctionTool constructor initialized");
+	}
+	getId() {
+		return this.id;
+	}
+	getName() {
+		return this.config.name;
+	}
+	getDescription() {
+		return this.config.description || "";
+	}
+	getInputSchema() {
+		return this.config.inputSchema;
+	}
+	getDependencies() {
+		return this.config.dependencies || {};
+	}
+	getExecuteFunction() {
+		if (typeof this.config.execute === "string") throw new Error("Cannot get execute function from string-based function tool. Use serializeFunction() instead.");
+		return this.config.execute;
+	}
+	serializeFunction() {
+		const executeCode = typeof this.config.execute === "string" ? this.config.execute : this.config.execute.toString();
+		return {
+			id: this.id,
+			inputSchema: this.config.inputSchema,
+			executeCode,
+			dependencies: this.config.dependencies || {}
+		};
+	}
+	serializeTool() {
+		return {
+			id: this.id,
+			name: this.config.name,
+			description: this.config.description,
+			functionId: this.id
+		};
+	}
+};
+
+//#endregion
+export { FunctionTool };