@inkeep/agents-sdk 0.39.5 → 0.40.0

package/dist/tool.js

@@ -0,0 +1,130 @@
+import { getLogger, normalizeToolSelections } from "@inkeep/agents-core";
+
+//#region src/tool.ts
+const logger = getLogger("tool");
+var Tool = class {
+	config;
+	baseURL;
+	tenantId;
+	initialized = false;
+	projectId;
+	constructor(config) {
+		this.config = config;
+		this.baseURL = process.env.INKEEP_API_URL || "http://localhost:3002";
+		this.tenantId = "default";
+		this.projectId = "default";
+		logger.info({
+			Id: this.getId(),
+			Name: config.name
+		}, "Tool constructor initialized");
+	}
+	setContext(tenantId, projectId, baseURL) {
+		this.tenantId = tenantId;
+		this.projectId = projectId;
+		if (baseURL) this.baseURL = baseURL;
+	}
+	getId() {
+		return this.config.id;
+	}
+	getName() {
+		return this.config.name;
+	}
+	getDescription() {
+		return this.config.description || "";
+	}
+	getServerUrl() {
+		return this.config.serverUrl;
+	}
+	getActiveTools() {
+		return this.config.activeTools;
+	}
+	getCredentialReferenceId() {
+		return this.config.credential?.id;
+	}
+	async init(options) {
+		if (this.initialized) return;
+		try {
+			if (!options?.skipDatabaseRegistration) await this.upsertTool();
+			logger.info({ toolId: this.getId() }, "Tool initialized successfully");
+			this.initialized = true;
+		} catch (error) {
+			logger.error({
+				toolId: this.getId(),
+				error: error instanceof Error ? error.message : "Unknown error"
+			}, "Failed to initialize tool");
+			throw error;
+		}
+	}
+	async upsertTool() {
+		const toolDataForUpdate = {
+			id: this.getId(),
+			name: this.config.name,
+			credentialReferenceId: this.config.credential?.id ?? null,
+			headers: this.config.headers ?? null,
+			imageUrl: this.config.imageUrl,
+			config: {
+				type: "mcp",
+				mcp: {
+					server: { url: this.config.serverUrl },
+					transport: this.config.transport,
+					activeTools: this.config.activeTools
+				}
+			}
+		};
+		const toolDataForCreate = { ...toolDataForUpdate };
+		logger.info({ toolDataForCreate }, "toolDataForCreate");
+		const updateResponse = await fetch(`${this.baseURL}/tenants/${this.tenantId}/projects/${this.projectId}/tools/${this.getId()}`, {
+			method: "PUT",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify(toolDataForUpdate)
+		});
+		logger.info({ updateResponse }, "tool updateResponse");
+		if (updateResponse.ok) {
+			logger.info({ toolId: this.getId() }, "Tool updated successfully");
+			return;
+		}
+		if (updateResponse.status === 404) {
+			logger.info({ toolId: this.getId() }, "Tool not found, creating new tool");
+			const createResponse = await fetch(`${this.baseURL}/tenants/${this.tenantId}/projects/${this.projectId}/tools`, {
+				method: "POST",
+				headers: { "Content-Type": "application/json" },
+				body: JSON.stringify(toolDataForCreate)
+			});
+			if (!createResponse.ok) throw new Error(`Failed to create tool: ${createResponse.status}`);
+			logger.info({ toolId: this.getId() }, "Tool created successfully");
+			return;
+		}
+		throw new Error(`Failed to update tool: ${updateResponse.status}`);
+	}
+	/**
+	* 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) {
+		const { selectedTools, toolPolicies } = normalizeToolSelections(config.selectedTools ?? void 0);
+		const isUnspecified = config.selectedTools === void 0 || config.selectedTools === null;
+		const resolvedSelectedTools = isUnspecified ? void 0 : selectedTools;
+		const resolvedToolPolicies = isUnspecified || Object.keys(toolPolicies).length === 0 ? void 0 : toolPolicies;
+		return {
+			server: this,
+			selectedTools: resolvedSelectedTools,
+			headers: config.headers,
+			toolPolicies: resolvedToolPolicies
+		};
+	}
+};
+
+//#endregion
+export { Tool };

package/dist/types.d.ts

@@ -0,0 +1,296 @@
+import { ArtifactComponentInterface } from "./artifact-component.js";
+import { Tool } from "./tool.js";
+import { AgentMcpConfig } from "./builders.js";
+import { DataComponentInterface } from "./data-component.js";
+import { ExternalAgentConfig } from "./external-agent.js";
+import { FunctionTool } from "./function-tool.js";
+import { AgentConversationHistoryConfig, AgentStopWhen, ArtifactComponentApiInsert, CredentialReferenceApiInsert, DataComponentApiInsert, FullAgentDefinition, FunctionToolConfig, McpTransportConfig, ModelSettings, StatusUpdateSettings, SubAgentApiInsert, ToolInsert, ToolPolicy } from "@inkeep/agents-core";
+import { z } from "zod";
+
+//#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
+export { AgentConfig, AgentError, AgentInterface, AgentResponse, AgentTool, AllDelegateInputInterface, AllDelegateOutputInterface, ArtifactComponentWithZodProps, AssistantMessage, BuilderAgentConfig, BuilderRelationConfig, BuilderToolConfig, DataComponentWithZodProps, ExternalAgentInterface, FetchDefinitionConfig, type FunctionToolConfig, GenerateOptions, MCPToolConfig, MaxTurnsExceededError, Message, MessageInput, type ModelSettings, RequestSchemaConfig, RequestSchemaDefinition, RunResult, ServerConfig, StreamEvent, StreamResponse, SubAgentCanUseType, SubAgentConfig, SubAgentInterface, SystemMessage, ToolCall, ToolConfig, ToolExecutionError, ToolMessage, ToolResult, TransferConfig, TransferError, UserMessage, subAgentExternalAgentInterface, subAgentTeamAgentInterface };

package/dist/types.js

@@ -0,0 +1,39 @@
+//#region src/types.ts
+var AgentError = class extends Error {
+	constructor(message, code, details) {
+		super(message);
+		this.code = code;
+		this.details = details;
+		this.name = "AgentError";
+	}
+};
+var MaxTurnsExceededError = class extends AgentError {
+	constructor(maxTurns) {
+		super(`Maximum turns (${maxTurns}) exceeded`);
+		this.code = "MAX_TURNS_EXCEEDED";
+	}
+};
+var ToolExecutionError = class extends AgentError {
+	constructor(toolName, originalError) {
+		super(`Tool '${toolName}' execution failed: ${originalError.message}`);
+		this.code = "TOOL_EXECUTION_ERROR";
+		this.details = {
+			toolName,
+			originalError
+		};
+	}
+};
+var TransferError = class extends AgentError {
+	constructor(sourceAgent, targetAgent, reason) {
+		super(`Transfer from '${sourceAgent}' to '${targetAgent}' failed: ${reason}`);
+		this.code = "TRANSFER_ERROR";
+		this.details = {
+			sourceAgent,
+			targetAgent,
+			reason
+		};
+	}
+};
+
+//#endregion
+export { AgentError, MaxTurnsExceededError, ToolExecutionError, TransferError };

package/dist/utils/generateIdFromName.d.ts

@@ -0,0 +1,9 @@
+//#region src/utils/generateIdFromName.d.ts
+/**
+ * Generates a kebab-case ID from a name string
+ * @param name - The name to convert
+ * @returns A kebab-case ID
+ */
+declare function generateIdFromName(name: string): string;
+//#endregion
+export { generateIdFromName };

package/dist/utils/generateIdFromName.js

@@ -0,0 +1,12 @@
+//#region src/utils/generateIdFromName.ts
+/**
+* Generates a kebab-case ID from a name string
+* @param name - The name to convert
+* @returns A kebab-case ID
+*/
+function generateIdFromName(name) {
+	return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+}
+
+//#endregion
+export { generateIdFromName };

package/dist/utils/getFunctionToolDeps.d.ts

@@ -0,0 +1,17 @@
+//#region src/utils/getFunctionToolDeps.d.ts
+declare const getFunctionToolDeps: (name: string, code: string) => Record<string, string | false>;
+type VersionResult = {
+  exact: string;
+} | {
+  range: string;
+  unresolved: true;
+};
+type ToolManifest = {
+  dependencies: Record<string, string | false>;
+  warnings: string[];
+};
+declare function collectDepsFromCodeTS(code: string): Set<string>;
+declare function resolveInstalledVersion(pkg: string, projectRoot: string): VersionResult | null;
+declare function buildToolManifestFromCodeTS(code: string, projectRoot?: string): ToolManifest;
+//#endregion
+export { ToolManifest, buildToolManifestFromCodeTS, collectDepsFromCodeTS, getFunctionToolDeps, resolveInstalledVersion };

package/dist/utils/getFunctionToolDeps.js

@@ -0,0 +1,131 @@
+import { builtinModules } from "node:module";
+import { getLogger } from "@inkeep/agents-core";
+import fs from "node:fs";
+import path from "node:path";
+import * as lockfile from "@yarnpkg/lockfile";
+import * as yaml from "js-yaml";
+import ts from "typescript";
+
+//#region src/utils/getFunctionToolDeps.ts
+const logger = getLogger("function-tool");
+const getFunctionToolDeps = (name, code) => {
+	const { dependencies, warnings } = buildToolManifestFromCodeTS(code);
+	if (warnings.length > 0) logger.warn({ warnings }, `FunctionTool dependencies warnings for ${name}`);
+	return dependencies;
+};
+const NODE_BUILTINS = new Set(builtinModules.concat(builtinModules.map((m) => `node:${m}`)));
+const isExternal = (spec) => !spec.startsWith(".") && !spec.startsWith("/") && !NODE_BUILTINS.has(spec);
+const collapseSubpath = (spec) => {
+	if (spec.startsWith("@")) {
+		const [scope, name] = spec.split("/");
+		return `${scope}/${name ?? ""}`;
+	}
+	return spec.split("/")[0];
+};
+const readJSON = (p) => JSON.parse(fs.readFileSync(p, "utf8"));
+const findUp = (start, file) => {
+	let dir = path.resolve(start);
+	if (fs.existsSync(dir) && fs.statSync(dir).isFile()) dir = path.dirname(dir);
+	for (;;) {
+		const candidate = path.join(dir, file);
+		if (fs.existsSync(candidate)) return candidate;
+		const parent = path.dirname(dir);
+		if (parent === dir) return null;
+		dir = parent;
+	}
+};
+function collectDepsFromCodeTS(code) {
+	const info = ts.preProcessFile(code, true, true);
+	const add = /* @__PURE__ */ new Set();
+	const push = (spec) => {
+		if (isExternal(spec)) add.add(collapseSubpath(spec));
+	};
+	for (const f of info.importedFiles) {
+		const spec = f.fileName;
+		if (spec) push(spec);
+	}
+	const requireLike = /(?:require|import)\s*\(\s*(['"])([^'"]+)\1\s*\)/g;
+	let m;
+	while (m = requireLike.exec(code)) push(m[2]);
+	return add;
+}
+function resolveInstalledVersion(pkg, projectRoot) {
+	const pnpmLock = findUp(projectRoot, "pnpm-lock.yaml");
+	if (pnpmLock) {
+		const pkgs = yaml.load(fs.readFileSync(pnpmLock, "utf8"))?.packages ?? {};
+		for (const key of Object.keys(pkgs)) if (key.startsWith(`${pkg}@`)) {
+			const ver = key.slice(key.indexOf("@") + 1);
+			if (ver) return { exact: String(ver) };
+		}
+	}
+	const npmLock = findUp(projectRoot, "package-lock.json");
+	if (npmLock) {
+		const lock = readJSON(npmLock);
+		if (lock.packages?.[`node_modules/${pkg}`]?.version) return { exact: String(lock.packages[`node_modules/${pkg}`].version) };
+		if (lock.dependencies?.[pkg]?.version) return { exact: String(lock.dependencies[pkg].version) };
+	}
+	const yarnLock = findUp(projectRoot, "yarn.lock");
+	if (yarnLock) {
+		const parsed = lockfile.parse(fs.readFileSync(yarnLock, "utf8"));
+		if (parsed.type === "success") {
+			for (const [key, val] of Object.entries(parsed.object)) if (key === pkg || key.startsWith(`${pkg}@`)) {
+				const ver = val.version;
+				if (ver) return { exact: String(ver) };
+			}
+		}
+	}
+	const host = {
+		fileExists: fs.existsSync,
+		readFile: (p) => fs.readFileSync(p, "utf8"),
+		realpath: (p) => fs.realpathSync.native?.(p) ?? fs.realpathSync(p),
+		directoryExists: (d) => {
+			try {
+				return fs.statSync(d).isDirectory();
+			} catch {
+				return false;
+			}
+		},
+		getCurrentDirectory: () => projectRoot,
+		getDirectories: (d) => fs.readdirSync(d, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name)
+	};
+	const pkgJsonPath = ts.resolveModuleName(`${pkg}/package.json`, path.join(projectRoot, "__fake.ts"), {}, host, ts.ModuleKind.NodeNext)?.resolvedModule?.resolvedFileName ?? findUp(path.join(projectRoot, "node_modules", pkg), "package.json");
+	if (pkgJsonPath && fs.existsSync(pkgJsonPath)) try {
+		const version = readJSON(pkgJsonPath).version;
+		if (version) return { exact: String(version) };
+	} catch {}
+	const hostPkg = findUp(projectRoot, "package.json");
+	if (hostPkg) {
+		const hostJson = readJSON(hostPkg);
+		const range = hostJson.dependencies?.[pkg] ?? hostJson.devDependencies?.[pkg] ?? hostJson.optionalDependencies?.[pkg];
+		if (range) return {
+			range: String(range),
+			unresolved: true
+		};
+	}
+	return null;
+}
+function buildToolManifestFromCodeTS(code, projectRoot = process.cwd()) {
+	const deps = collectDepsFromCodeTS(code);
+	const warnings = [];
+	const dependencies = {};
+	for (const pkg of deps) try {
+		const v = resolveInstalledVersion(pkg, projectRoot);
+		if (!v) {
+			warnings.push(`Could not resolve version for "${pkg}"`);
+			continue;
+		}
+		if ("unresolved" in v) {
+			warnings.push(`Using range for "${pkg}" -> ${v.range} (no lockfile / not installed)`);
+			dependencies[pkg] = v.range;
+		} else dependencies[pkg] = v.exact;
+	} catch {
+		dependencies[pkg] = false;
+	}
+	return {
+		dependencies,
+		warnings
+	};
+}
+
+//#endregion
+export { buildToolManifestFromCodeTS, collectDepsFromCodeTS, getFunctionToolDeps, resolveInstalledVersion };

package/dist/utils/tool-normalization.d.ts

@@ -0,0 +1,42 @@
+import { Tool } from "../tool.js";
+import { AgentMcpConfig } from "../builders.js";
+import { SubAgentCanUseType } from "../types.js";
+import { ToolPolicy } from "@inkeep/agents-core";
+
+//#region src/utils/tool-normalization.d.ts
+
+/**
+ * Type guard to check if a value is an AgentMcpConfig
+ */
+declare function isAgentMcpConfig(value: unknown): value is AgentMcpConfig;
+/**
+ * Type guard to check if a value is a Tool instance
+ */
+declare function isTool(value: unknown): value is Tool;
+/**
+ * Type guard to narrow down AgentCanUseType
+ */
+declare function isAgentCanUseType(value: unknown): value is SubAgentCanUseType;
+/**
+ * Normalized tool representation with proper typing
+ */
+interface NormalizedToolInfo {
+  /** The underlying Tool instance */
+  tool: Tool;
+  /** The tool ID */
+  toolId: string;
+  /** Selected tools (only present for AgentMcpConfig) */
+  selectedTools?: string[];
+  /** Agent-specific headers (only present for AgentMcpConfig) */
+  headers?: Record<string, string>;
+  /** Per-tool policies like needsApproval (only present for AgentMcpConfig) */
+  toolPolicies?: Record<string, ToolPolicy>;
+  /** Whether this came from an AgentMcpConfig wrapper */
+  isWrapped: boolean;
+}
+/**
+ * Safely extracts tool information from AgentCanUseType with proper typing
+ */
+declare function normalizeAgentCanUseType(value: SubAgentCanUseType, fallbackName?: string): NormalizedToolInfo;
+//#endregion
+export { NormalizedToolInfo, isAgentCanUseType, isAgentMcpConfig, isTool, normalizeAgentCanUseType };