@inkeep/agents-run-api 0.39.5 → 0.40.0

package/dist/services/MidGenerationCompressor.js

@@ -0,0 +1,104 @@
+import { getLogger } from "../logger.js";
+import { BaseCompressor, getModelAwareCompressionConfig } from "./BaseCompressor.js";
+
+//#region src/services/MidGenerationCompressor.ts
+const logger = getLogger("MidGenerationCompressor");
+/**
+* Mid-generation compressor
+* Compresses context when generate() steps get too large with manual compression support
+*/
+var MidGenerationCompressor = class extends BaseCompressor {
+	shouldCompress = false;
+	lastProcessedMessageIndex = 0;
+	constructor(sessionId, conversationId, tenantId, projectId, config, summarizerModel, baseModel) {
+		const compressionConfig = config || getModelAwareCompressionConfig(summarizerModel);
+		super(sessionId, conversationId, tenantId, projectId, compressionConfig, summarizerModel, baseModel);
+	}
+	/**
+	* Get compression type for this compressor
+	*/
+	getCompressionType() {
+		return "mid_generation";
+	}
+	/**
+	* Manual compression request from LLM tool
+	*/
+	requestManualCompression(reason) {
+		this.shouldCompress = true;
+		logger.info({
+			sessionId: this.sessionId,
+			reason: reason || "Manual request from LLM"
+		}, "Manual compression requested");
+	}
+	/**
+	* Check if compression is needed (either automatic or manual)
+	* Supports manual compression requests unique to mid-generation
+	*/
+	isCompressionNeeded(messages) {
+		if (this.shouldCompress) return true;
+		const contextSize = this.calculateContextSize(messages);
+		const remaining = this.config.hardLimit - contextSize;
+		const needsCompression = remaining <= this.config.safetyBuffer;
+		logger.debug({
+			sessionId: this.sessionId,
+			contextSize,
+			hardLimit: this.config.hardLimit,
+			safetyBuffer: this.config.safetyBuffer,
+			remaining,
+			needsCompression,
+			manualRequest: this.shouldCompress
+		}, "Checking mid-generation compression criteria");
+		return needsCompression;
+	}
+	/**
+	* Perform mid-generation compression with incremental processing
+	* Uses base class functionality with mid-generation specific logic
+	*/
+	async compress(messages) {
+		const contextSizeBefore = this.calculateContextSize(messages);
+		logger.info({
+			sessionId: this.sessionId,
+			messageCount: messages.length,
+			contextSize: contextSizeBefore
+		}, "MID-GENERATION COMPRESSION: Starting compression");
+		const toolCallToArtifactMap = await this.saveToolResultsAsArtifacts(messages, this.lastProcessedMessageIndex);
+		const summary = await this.createConversationSummary(messages, toolCallToArtifactMap);
+		const contextSizeAfter = this.estimateTokens(JSON.stringify(summary));
+		this.recordCompressionEvent({
+			reason: this.shouldCompress ? "manual" : "automatic",
+			messageCount: messages.length,
+			artifactCount: Object.keys(toolCallToArtifactMap).length,
+			contextSizeBefore,
+			contextSizeAfter,
+			compressionType: this.getCompressionType()
+		});
+		this.shouldCompress = false;
+		this.lastProcessedMessageIndex = messages.length;
+		logger.info({
+			sessionId: this.sessionId,
+			artifactsCreated: Object.keys(toolCallToArtifactMap).length,
+			messageCount: messages.length,
+			contextSizeBefore,
+			contextSizeAfter,
+			compressionRatio: contextSizeAfter / contextSizeBefore,
+			artifactIds: Object.values(toolCallToArtifactMap)
+		}, "MID-GENERATION COMPRESSION: Compression completed successfully");
+		return {
+			artifactIds: Object.values(toolCallToArtifactMap),
+			summary
+		};
+	}
+	/**
+	* Get current state for debugging
+	*/
+	getState() {
+		return {
+			...super.getState(),
+			shouldCompress: this.shouldCompress,
+			lastProcessedMessageIndex: this.lastProcessedMessageIndex
+		};
+	}
+};
+
+//#endregion
+export { MidGenerationCompressor };

package/dist/services/PendingToolApprovalManager.d.ts

@@ -0,0 +1,62 @@
+//#region src/services/PendingToolApprovalManager.d.ts
+interface PendingToolApproval {
+  toolCallId: string;
+  toolName: string;
+  args: any;
+  conversationId: string;
+  subAgentId: string;
+  createdAt: number;
+  resolve: (result: {
+    approved: boolean;
+    reason?: string;
+  }) => void;
+  reject: (error: Error) => void;
+  timeoutId: ReturnType<typeof setTimeout>;
+}
+/**
+ * Manages pending tool approval requests during agent execution.
+ * Similar to ToolSessionManager but for approval workflows.
+ * Uses in-memory Map storage with automatic cleanup like OAuth PKCE store.
+ */
+declare class PendingToolApprovalManager {
+  private static instance;
+  private pendingApprovals;
+  private constructor();
+  static getInstance(): PendingToolApprovalManager;
+  /**
+   * Create a new pending approval and return a promise that resolves with approval status
+   */
+  waitForApproval(toolCallId: string, toolName: string, args: any, conversationId: string, subAgentId: string): Promise<{
+    approved: boolean;
+    reason?: string;
+  }>;
+  /**
+   * Approve a pending tool call
+   */
+  approveToolCall(toolCallId: string): boolean;
+  /**
+   * Deny a pending tool call
+   */
+  denyToolCall(toolCallId: string, reason?: string): boolean;
+  /**
+   * Clean up expired approvals (called by interval timer)
+   */
+  private cleanupExpiredApprovals;
+  /**
+   * Get current status for monitoring
+   */
+  getStatus(): {
+    pendingApprovals: number;
+    approvals: {
+      toolCallId: string;
+      toolName: string;
+      conversationId: string;
+      subAgentId: string;
+      createdAt: number;
+      age: number;
+    }[];
+  };
+}
+declare const pendingToolApprovalManager: PendingToolApprovalManager;
+//#endregion
+export { PendingToolApproval, PendingToolApprovalManager, pendingToolApprovalManager };

package/dist/services/PendingToolApprovalManager.js

@@ -0,0 +1,133 @@
+import { getLogger } from "../logger.js";
+
+//#region src/services/PendingToolApprovalManager.ts
+const logger = getLogger("PendingToolApprovalManager");
+const APPROVAL_CLEANUP_INTERVAL_MS = 120 * 1e3;
+const APPROVAL_TIMEOUT_MS = 600 * 1e3;
+/**
+* Manages pending tool approval requests during agent execution.
+* Similar to ToolSessionManager but for approval workflows.
+* Uses in-memory Map storage with automatic cleanup like OAuth PKCE store.
+*/
+var PendingToolApprovalManager = class PendingToolApprovalManager {
+	static instance;
+	pendingApprovals = /* @__PURE__ */ new Map();
+	constructor() {
+		setInterval(() => this.cleanupExpiredApprovals(), APPROVAL_CLEANUP_INTERVAL_MS);
+	}
+	static getInstance() {
+		if (!PendingToolApprovalManager.instance) PendingToolApprovalManager.instance = new PendingToolApprovalManager();
+		return PendingToolApprovalManager.instance;
+	}
+	/**
+	* Create a new pending approval and return a promise that resolves with approval status
+	*/
+	async waitForApproval(toolCallId, toolName, args, conversationId, subAgentId) {
+		return new Promise((resolve, reject) => {
+			const timeoutId = setTimeout(() => {
+				this.pendingApprovals.delete(toolCallId);
+				resolve({
+					approved: false,
+					reason: `Tool approval timeout for ${toolName} (${toolCallId})`
+				});
+			}, APPROVAL_TIMEOUT_MS);
+			const approval = {
+				toolCallId,
+				toolName,
+				args,
+				conversationId,
+				subAgentId,
+				createdAt: Date.now(),
+				resolve,
+				reject,
+				timeoutId
+			};
+			this.pendingApprovals.set(toolCallId, approval);
+			logger.info({
+				toolCallId,
+				toolName,
+				conversationId,
+				subAgentId
+			}, "Tool approval request created, waiting for user response");
+		});
+	}
+	/**
+	* Approve a pending tool call
+	*/
+	approveToolCall(toolCallId) {
+		const approval = this.pendingApprovals.get(toolCallId);
+		if (!approval) {
+			logger.warn({ toolCallId }, "Tool approval not found or already processed");
+			return false;
+		}
+		logger.info({
+			toolCallId,
+			toolName: approval.toolName,
+			conversationId: approval.conversationId
+		}, "Tool approved by user, resuming execution");
+		clearTimeout(approval.timeoutId);
+		this.pendingApprovals.delete(toolCallId);
+		approval.resolve({ approved: true });
+		return true;
+	}
+	/**
+	* Deny a pending tool call
+	*/
+	denyToolCall(toolCallId, reason) {
+		const approval = this.pendingApprovals.get(toolCallId);
+		if (!approval) {
+			logger.warn({ toolCallId }, "Tool approval not found or already processed");
+			return false;
+		}
+		logger.info({
+			toolCallId,
+			toolName: approval.toolName,
+			conversationId: approval.conversationId,
+			reason
+		}, "Tool execution denied by user");
+		clearTimeout(approval.timeoutId);
+		this.pendingApprovals.delete(toolCallId);
+		approval.resolve({
+			approved: false,
+			reason: reason || "User denied approval"
+		});
+		return true;
+	}
+	/**
+	* Clean up expired approvals (called by interval timer)
+	*/
+	cleanupExpiredApprovals() {
+		const now = Date.now();
+		let cleanedUp = 0;
+		for (const [toolCallId, approval] of this.pendingApprovals) if (now - approval.createdAt > APPROVAL_TIMEOUT_MS) {
+			clearTimeout(approval.timeoutId);
+			this.pendingApprovals.delete(toolCallId);
+			approval.resolve({
+				approved: false,
+				reason: "Tool approval expired"
+			});
+			cleanedUp++;
+		}
+		if (cleanedUp > 0) logger.info({ cleanedUp }, "Cleaned up expired tool approvals");
+	}
+	/**
+	* Get current status for monitoring
+	*/
+	getStatus() {
+		return {
+			pendingApprovals: this.pendingApprovals.size,
+			approvals: Array.from(this.pendingApprovals.values()).map((approval) => ({
+				toolCallId: approval.toolCallId,
+				toolName: approval.toolName,
+				conversationId: approval.conversationId,
+				subAgentId: approval.subAgentId,
+				createdAt: approval.createdAt,
+				age: Date.now() - approval.createdAt
+			}))
+		};
+	}
+};
+const pendingToolApprovalManager = PendingToolApprovalManager.getInstance();
+
+//#endregion
+export { PendingToolApprovalManager, pendingToolApprovalManager };

package/dist/services/ResponseFormatter.d.ts

@@ -0,0 +1,39 @@
+import { MessageContent } from "@inkeep/agents-core";
+
+//#region src/services/ResponseFormatter.d.ts
+
+/**
+ * Response formatter that uses the unified ArtifactParser to convert artifact markers
+ * into data parts for consistent artifact handling across all agent responses
+ */
+declare class ResponseFormatter {
+  private artifactParser;
+  private subAgentId?;
+  constructor(tenantId: string, artifactParserOptions?: {
+    sessionId?: string;
+    taskId?: string;
+    projectId?: string;
+    contextId?: string;
+    artifactComponents?: any[];
+    streamRequestId?: string;
+    subAgentId?: string;
+  });
+  /**
+   * Process structured object response and replace artifact markers with actual artifacts
+   */
+  formatObjectResponse(responseObject: any, contextId: string): Promise<MessageContent>;
+  /**
+   * Process agent response and convert artifact markers to data parts
+   */
+  formatResponse(responseText: string, contextId: string): Promise<MessageContent>;
+  /**
+   * Count unique artifacts in parts array
+   */
+  private countUniqueArtifacts;
+  /**
+   * Log artifacts found in parts to span
+   */
+  private logArtifacts;
+}
+//#endregion
+export { ResponseFormatter };

package/dist/services/ResponseFormatter.js

@@ -0,0 +1,152 @@
+import { getLogger } from "../logger.js";
+import { setSpanWithError, tracer } from "../utils/tracer.js";
+import { ArtifactParser } from "./ArtifactParser.js";
+import { agentSessionManager } from "./AgentSession.js";
+
+//#region src/services/ResponseFormatter.ts
+const logger = getLogger("ResponseFormatter");
+/**
+* Response formatter that uses the unified ArtifactParser to convert artifact markers
+* into data parts for consistent artifact handling across all agent responses
+*/
+var ResponseFormatter = class {
+	artifactParser;
+	subAgentId;
+	constructor(tenantId, artifactParserOptions) {
+		this.subAgentId = artifactParserOptions?.subAgentId;
+		if (artifactParserOptions?.streamRequestId) {
+			const sessionParser = agentSessionManager.getArtifactParser(artifactParserOptions.streamRequestId);
+			if (sessionParser) {
+				this.artifactParser = sessionParser;
+				return;
+			}
+		}
+		let sharedArtifactService = null;
+		if (artifactParserOptions?.streamRequestId && typeof agentSessionManager.getArtifactService === "function") try {
+			sharedArtifactService = agentSessionManager.getArtifactService(artifactParserOptions.streamRequestId);
+		} catch (_error) {}
+		this.artifactParser = new ArtifactParser(tenantId, {
+			...artifactParserOptions,
+			artifactService: sharedArtifactService
+		});
+	}
+	/**
+	* Process structured object response and replace artifact markers with actual artifacts
+	*/
+	async formatObjectResponse(responseObject, contextId) {
+		return tracer.startActiveSpan("response.format_object_response", async (span) => {
+			try {
+				const artifactMap = await this.artifactParser.getContextArtifacts(contextId);
+				span.setAttributes({
+					"response.type": "object",
+					"response.availableArtifacts": artifactMap.size
+				});
+				const parts = await this.artifactParser.parseObject(responseObject, artifactMap, this.subAgentId);
+				const uniqueArtifacts = this.countUniqueArtifacts(parts);
+				span.setAttributes({
+					"response.dataPartsCount": parts.length,
+					"response.artifactsCount": uniqueArtifacts,
+					"response.totalPartsCount": parts.length
+				});
+				this.logArtifacts(span, parts);
+				span.addEvent("response.parts.final_output", { final_parts_array: JSON.stringify(parts, null, 2) });
+				return { parts };
+			} catch (error) {
+				setSpanWithError(span, error instanceof Error ? error : new Error(String(error)));
+				logger.error({
+					error,
+					responseObject
+				}, "Error formatting object response");
+				return { parts: [{
+					kind: "data",
+					data: responseObject
+				}] };
+			} finally {
+				span.end();
+			}
+		});
+	}
+	/**
+	* Process agent response and convert artifact markers to data parts
+	*/
+	async formatResponse(responseText, contextId) {
+		return tracer.startActiveSpan("response.format_response", async (span) => {
+			try {
+				const hasMarkers = this.artifactParser.hasArtifactMarkers(responseText);
+				span.setAttributes({
+					"response.hasArtifactMarkers": hasMarkers,
+					"response.contextId": contextId,
+					"response.textLength": responseText.length
+				});
+				if (!this.artifactParser.hasArtifactMarkers(responseText)) {
+					span.setAttributes({ "response.result": "no_markers_found" });
+					return { parts: [{
+						kind: "text",
+						text: responseText
+					}] };
+				}
+				const artifactMap = await this.artifactParser.getContextArtifacts(contextId);
+				span.setAttributes({
+					"response.type": "text",
+					"response.availableArtifacts": artifactMap.size
+				});
+				const parts = await this.artifactParser.parseText(responseText, artifactMap, this.subAgentId);
+				if (parts.length === 1 && parts[0].kind === "text") return { text: parts[0].text };
+				const textParts = parts.filter((p) => p.kind === "text").length;
+				const dataParts = parts.filter((p) => p.kind === "data").length;
+				const uniqueArtifacts = this.countUniqueArtifacts(parts);
+				span.setAttributes({
+					"response.textPartsCount": textParts,
+					"response.dataPartsCount": dataParts,
+					"response.artifactsCount": uniqueArtifacts,
+					"response.totalPartsCount": parts.length
+				});
+				this.logArtifacts(span, parts);
+				span.addEvent("response.parts.final_output", { final_parts_array: JSON.stringify(parts, null, 2) });
+				return { parts };
+			} catch (error) {
+				setSpanWithError(span, error instanceof Error ? error : new Error(String(error)));
+				logger.error({
+					error,
+					responseText
+				}, "Error formatting response");
+				return { text: responseText };
+			} finally {
+				span.end();
+			}
+		});
+	}
+	/**
+	* Count unique artifacts in parts array
+	*/
+	countUniqueArtifacts(parts) {
+		return new Set(parts.filter((p) => p.kind === "data").map((p) => {
+			const data = p.data;
+			if (data?.artifactId && data?.taskId) return `${data.artifactId}:${data.taskId}`;
+			return null;
+		}).filter((key) => key !== null)).size;
+	}
+	/**
+	* Log artifacts found in parts to span
+	*/
+	logArtifacts(span, parts) {
+		const artifacts = parts.filter((p) => p.kind === "data").map((p) => {
+			const data = p.data;
+			return {
+				artifactId: data?.artifactId,
+				name: data?.name,
+				taskId: data?.taskId
+			};
+		}).filter((art) => art.artifactId && art.taskId);
+		if (artifacts.length > 0) {
+			const uniqueArtifactsList = Array.from(new Map(artifacts.map((art) => [`${art.artifactId}:${art.taskId}`, art])).values());
+			span.addEvent("artifacts.found", {
+				"artifacts.count": uniqueArtifactsList.length,
+				"artifacts.list": JSON.stringify(uniqueArtifactsList)
+			});
+		}
+	}
+};
+
+//#endregion
+export { ResponseFormatter };

package/dist/tools/NativeSandboxExecutor.d.ts

@@ -0,0 +1,38 @@
+import { SandboxConfig } from "../types/execution-context.js";
+
+//#region src/tools/NativeSandboxExecutor.d.ts
+
+interface FunctionToolConfig {
+  name?: string;
+  description: string;
+  inputSchema: Record<string, unknown>;
+  executeCode: string;
+  dependencies: Record<string, string>;
+  sandboxConfig?: SandboxConfig;
+}
+declare class NativeSandboxExecutor {
+  private tempDir;
+  private sandboxPool;
+  private static instance;
+  private executionSemaphores;
+  constructor();
+  static getInstance(): NativeSandboxExecutor;
+  private getSemaphore;
+  getExecutionStats(): Record<string, {
+    availablePermits: number;
+    queueLength: number;
+  }>;
+  private ensureTempDir;
+  private generateDependencyHash;
+  private getCachedSandbox;
+  private addToPool;
+  private cleanupSandbox;
+  private startPoolCleanup;
+  private detectModuleType;
+  executeFunctionTool(toolId: string, args: any, config: FunctionToolConfig): Promise<any>;
+  private executeInSandbox_Internal;
+  private installDependencies;
+  private executeInSandbox;
+}
+//#endregion
+export { FunctionToolConfig, NativeSandboxExecutor };