@inkeep/agents-run-api 0.39.5 → 0.41.0

package/dist/tools/VercelSandboxExecutor.js

@@ -0,0 +1,340 @@
+import { getLogger } from "../logger.js";
+import { FUNCTION_TOOL_SANDBOX_CLEANUP_INTERVAL_MS, FUNCTION_TOOL_SANDBOX_MAX_USE_COUNT, FUNCTION_TOOL_SANDBOX_POOL_TTL_MS } from "../constants/execution-limits/index.js";
+import { createExecutionWrapper, parseExecutionResult } from "./sandbox-utils.js";
+import crypto from "node:crypto";
+import { Sandbox } from "@vercel/sandbox";
+
+//#region src/tools/VercelSandboxExecutor.ts
+const logger = getLogger("VercelSandboxExecutor");
+/**
+* Vercel Sandbox Executor with pooling/reuse
+* Executes function tools in isolated Vercel Sandbox MicroVMs
+* Caches and reuses sandboxes based on dependencies to improve performance
+*/
+var VercelSandboxExecutor = class VercelSandboxExecutor {
+	static instance;
+	config;
+	sandboxPool = /* @__PURE__ */ new Map();
+	cleanupInterval = null;
+	constructor(config) {
+		this.config = config;
+		logger.info({
+			teamId: config.teamId,
+			projectId: config.projectId,
+			runtime: config.runtime,
+			timeout: config.timeout,
+			vcpus: config.vcpus
+		}, "VercelSandboxExecutor initialized with pooling");
+		this.startPoolCleanup();
+	}
+	/**
+	* Get singleton instance of VercelSandboxExecutor
+	*/
+	static getInstance(config) {
+		if (!VercelSandboxExecutor.instance) VercelSandboxExecutor.instance = new VercelSandboxExecutor(config);
+		return VercelSandboxExecutor.instance;
+	}
+	/**
+	* Generate a hash for dependencies to use as cache key
+	*/
+	generateDependencyHash(dependencies) {
+		const sorted = Object.keys(dependencies).sort().map((key) => `${key}@${dependencies[key]}`).join(",");
+		return crypto.createHash("md5").update(sorted).digest("hex").substring(0, 8);
+	}
+	/**
+	* Get a cached sandbox if available and still valid
+	*/
+	getCachedSandbox(dependencyHash) {
+		const cached = this.sandboxPool.get(dependencyHash);
+		if (!cached) return null;
+		const age = Date.now() - cached.createdAt;
+		if (age > FUNCTION_TOOL_SANDBOX_POOL_TTL_MS || cached.useCount >= FUNCTION_TOOL_SANDBOX_MAX_USE_COUNT) {
+			logger.debug({
+				dependencyHash,
+				age,
+				useCount: cached.useCount,
+				ttl: FUNCTION_TOOL_SANDBOX_POOL_TTL_MS,
+				maxUseCount: FUNCTION_TOOL_SANDBOX_MAX_USE_COUNT
+			}, "Sandbox expired, will create new one");
+			this.removeSandbox(dependencyHash);
+			return null;
+		}
+		logger.debug({
+			dependencyHash,
+			useCount: cached.useCount,
+			age
+		}, "Reusing cached sandbox");
+		return cached.sandbox;
+	}
+	/**
+	* Add sandbox to pool
+	*/
+	addToPool(dependencyHash, sandbox, dependencies) {
+		this.sandboxPool.set(dependencyHash, {
+			sandbox,
+			createdAt: Date.now(),
+			useCount: 0,
+			dependencies
+		});
+		logger.debug({
+			dependencyHash,
+			poolSize: this.sandboxPool.size
+		}, "Sandbox added to pool");
+	}
+	/**
+	* Increment use count for a sandbox
+	*/
+	incrementUseCount(dependencyHash) {
+		const cached = this.sandboxPool.get(dependencyHash);
+		if (cached) cached.useCount++;
+	}
+	/**
+	* Remove and clean up a sandbox
+	*/
+	async removeSandbox(dependencyHash) {
+		const cached = this.sandboxPool.get(dependencyHash);
+		if (cached) {
+			try {
+				await cached.sandbox.stop();
+				logger.debug({ dependencyHash }, "Sandbox stopped");
+			} catch (error) {
+				logger.warn({
+					error,
+					dependencyHash
+				}, "Error stopping sandbox");
+			}
+			this.sandboxPool.delete(dependencyHash);
+		}
+	}
+	/**
+	* Start periodic cleanup of expired sandboxes
+	*/
+	startPoolCleanup() {
+		this.cleanupInterval = setInterval(() => {
+			const now = Date.now();
+			const toRemove = [];
+			for (const [hash, cached] of this.sandboxPool.entries()) if (now - cached.createdAt > FUNCTION_TOOL_SANDBOX_POOL_TTL_MS || cached.useCount >= FUNCTION_TOOL_SANDBOX_MAX_USE_COUNT) toRemove.push(hash);
+			if (toRemove.length > 0) {
+				logger.info({
+					count: toRemove.length,
+					poolSize: this.sandboxPool.size
+				}, "Cleaning up expired sandboxes");
+				for (const hash of toRemove) this.removeSandbox(hash);
+			}
+		}, FUNCTION_TOOL_SANDBOX_CLEANUP_INTERVAL_MS);
+	}
+	/**
+	* Cleanup all sandboxes and stop cleanup interval
+	*/
+	async cleanup() {
+		if (this.cleanupInterval) {
+			clearInterval(this.cleanupInterval);
+			this.cleanupInterval = null;
+		}
+		logger.info({ poolSize: this.sandboxPool.size }, "Cleaning up all sandboxes");
+		const promises = Array.from(this.sandboxPool.keys()).map((hash) => this.removeSandbox(hash));
+		await Promise.all(promises);
+	}
+	/**
+	* Extract environment variable names from code
+	* Matches patterns like process.env.VAR_NAME or process.env['VAR_NAME']
+	*/
+	extractEnvVars(code) {
+		const envVars = /* @__PURE__ */ new Set();
+		const dotNotationRegex = /process\.env\.([A-Z_][A-Z0-9_]*)/g;
+		let match = dotNotationRegex.exec(code);
+		while (match !== null) {
+			envVars.add(match[1]);
+			match = dotNotationRegex.exec(code);
+		}
+		const bracketNotationRegex = /process\.env\[['"]([A-Z_][A-Z0-9_]*)['"]\]/g;
+		match = bracketNotationRegex.exec(code);
+		while (match !== null) {
+			envVars.add(match[1]);
+			match = bracketNotationRegex.exec(code);
+		}
+		return envVars;
+	}
+	/**
+	* Create .env file content from environment variables
+	* Note: Currently creates empty placeholders. Values will be populated in the future.
+	*/
+	createEnvFileContent(envVarNames) {
+		const envLines = [];
+		for (const varName of envVarNames) {
+			envLines.push(`${varName}=""`);
+			logger.debug({ varName }, "Adding environment variable placeholder to sandbox");
+		}
+		return envLines.join("\n");
+	}
+	/**
+	* Execute a function tool in Vercel Sandbox with pooling
+	*/
+	async executeFunctionTool(functionId, args, toolConfig) {
+		const startTime = Date.now();
+		const logs = [];
+		const dependencies = toolConfig.dependencies || {};
+		const dependencyHash = this.generateDependencyHash(dependencies);
+		try {
+			logger.info({
+				functionId,
+				functionName: toolConfig.name,
+				dependencyHash,
+				poolSize: this.sandboxPool.size
+			}, "Executing function in Vercel Sandbox");
+			let sandbox = this.getCachedSandbox(dependencyHash);
+			let isNewSandbox = false;
+			if (!sandbox) {
+				isNewSandbox = true;
+				sandbox = await Sandbox.create({
+					token: this.config.token,
+					teamId: this.config.teamId,
+					projectId: this.config.projectId,
+					timeout: this.config.timeout,
+					resources: { vcpus: this.config.vcpus || 1 },
+					runtime: this.config.runtime
+				});
+				logger.info({
+					functionId,
+					sandboxId: sandbox.sandboxId,
+					dependencyHash
+				}, `New sandbox created for function ${functionId}`);
+				this.addToPool(dependencyHash, sandbox, dependencies);
+			} else logger.info({
+				functionId,
+				sandboxId: sandbox.sandboxId,
+				dependencyHash
+			}, `Reusing cached sandbox for function ${functionId}`);
+			this.incrementUseCount(dependencyHash);
+			try {
+				if (isNewSandbox && toolConfig.dependencies && Object.keys(toolConfig.dependencies).length > 0) {
+					logger.debug({
+						functionId,
+						functionName: toolConfig.name,
+						dependencies: toolConfig.dependencies
+					}, "Installing dependencies in new sandbox");
+					const packageJson = { dependencies: toolConfig.dependencies };
+					const packageJsonContent = JSON.stringify(packageJson, null, 2);
+					await sandbox.writeFiles([{
+						path: "package.json",
+						content: Buffer.from(packageJsonContent, "utf-8")
+					}]);
+					const installCmd = await sandbox.runCommand({
+						cmd: "npm",
+						args: ["install", "--omit=dev"]
+					});
+					const installStdout = await installCmd.stdout();
+					const installStderr = await installCmd.stderr();
+					if (installStdout) logs.push(installStdout);
+					if (installStderr) logs.push(installStderr);
+					if (installCmd.exitCode !== 0) throw new Error(`Failed to install dependencies: ${installStderr}`);
+					logger.info({
+						functionId,
+						dependencyHash
+					}, "Dependencies installed successfully");
+				}
+				const executionCode = createExecutionWrapper(toolConfig.executeCode, args);
+				const envVars = this.extractEnvVars(toolConfig.executeCode);
+				const filesToWrite = [];
+				const filename = this.config.runtime === "typescript" ? "execute.ts" : "execute.js";
+				filesToWrite.push({
+					path: filename,
+					content: Buffer.from(executionCode, "utf-8")
+				});
+				if (envVars.size > 0) {
+					const envFileContent = this.createEnvFileContent(envVars);
+					if (envFileContent) {
+						filesToWrite.push({
+							path: ".env",
+							content: Buffer.from(envFileContent, "utf-8")
+						});
+						logger.info({
+							functionId,
+							envVarCount: envVars.size,
+							envVars: Array.from(envVars)
+						}, "Creating environment variable placeholders in sandbox");
+					}
+				}
+				await sandbox.writeFiles(filesToWrite);
+				logger.info({
+					functionId,
+					runtime: this.config.runtime === "typescript" ? "tsx" : "node",
+					hasEnvVars: envVars.size > 0
+				}, `Execution code written to file for runtime ${this.config.runtime}`);
+				const executeCmd = await (async () => {
+					if (envVars.size > 0) return sandbox.runCommand({
+						cmd: "npx",
+						args: this.config.runtime === "typescript" ? [
+							"--yes",
+							"dotenv-cli",
+							"--",
+							"npx",
+							"tsx",
+							filename
+						] : [
+							"--yes",
+							"dotenv-cli",
+							"--",
+							"node",
+							filename
+						]
+					});
+					const runtime = this.config.runtime === "typescript" ? "tsx" : "node";
+					return sandbox.runCommand({
+						cmd: runtime,
+						args: [filename]
+					});
+				})();
+				const executeStdout = await executeCmd.stdout();
+				const executeStderr = await executeCmd.stderr();
+				if (executeStdout) logs.push(executeStdout);
+				if (executeStderr) logs.push(executeStderr);
+				const executionTime = Date.now() - startTime;
+				if (executeCmd.exitCode !== 0) {
+					logger.error({
+						functionId,
+						exitCode: executeCmd.exitCode,
+						stderr: executeStderr
+					}, "Function execution failed");
+					return {
+						success: false,
+						error: executeStderr || "Function execution failed with non-zero exit code",
+						logs,
+						executionTime
+					};
+				}
+				const result = parseExecutionResult(executeStdout, functionId, logger);
+				logger.info({
+					functionId,
+					executionTime
+				}, "Function executed successfully in Vercel Sandbox");
+				return {
+					success: true,
+					result,
+					logs,
+					executionTime
+				};
+			} catch (innerError) {
+				await this.removeSandbox(dependencyHash);
+				throw innerError;
+			}
+		} catch (error) {
+			const executionTime = Date.now() - startTime;
+			const errorMessage = error instanceof Error ? error.message : String(error);
+			logger.error({
+				functionId,
+				error: errorMessage,
+				executionTime
+			}, "Vercel Sandbox execution error");
+			return {
+				success: false,
+				error: errorMessage,
+				logs,
+				executionTime
+			};
+		}
+	}
+};
+
+//#endregion
+export { VercelSandboxExecutor };

package/dist/tools/distill-conversation-history-tool.d.ts

@@ -0,0 +1,62 @@
+import { ModelSettings } from "@inkeep/agents-core";
+import { z } from "zod";
+
+//#region src/tools/distill-conversation-history-tool.d.ts
+
+/**
+ * Conversation History Summary Schema - structured object for replacing entire conversation histories
+ */
+declare const ConversationHistorySummarySchema: z.ZodObject<{
+  type: z.ZodLiteral<"conversation_history_summary_v1">;
+  session_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+  conversation_overview: z.ZodString;
+  user_goals: z.ZodObject<{
+    primary: z.ZodString;
+    secondary: z.ZodArray<z.ZodString>;
+  }, z.core.$strip>;
+  key_outcomes: z.ZodObject<{
+    completed: z.ZodArray<z.ZodString>;
+    partial: z.ZodArray<z.ZodString>;
+    discoveries: z.ZodArray<z.ZodString>;
+  }, z.core.$strip>;
+  technical_context: z.ZodObject<{
+    technologies: z.ZodArray<z.ZodString>;
+    configurations: z.ZodArray<z.ZodString>;
+    issues_encountered: z.ZodArray<z.ZodString>;
+    solutions_applied: z.ZodArray<z.ZodString>;
+  }, z.core.$strip>;
+  conversation_artifacts: z.ZodOptional<z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    tool_name: z.ZodString;
+    tool_call_id: z.ZodString;
+    content_summary: z.ZodString;
+    relevance: z.ZodEnum<{
+      high: "high";
+      medium: "medium";
+      low: "low";
+    }>;
+  }, z.core.$strip>>>;
+  conversation_flow: z.ZodObject<{
+    major_phases: z.ZodArray<z.ZodString>;
+    decision_points: z.ZodArray<z.ZodString>;
+    topic_shifts: z.ZodArray<z.ZodString>;
+  }, z.core.$strip>;
+  context_for_continuation: z.ZodObject<{
+    current_state: z.ZodString;
+    next_logical_steps: z.ZodArray<z.ZodString>;
+    important_context: z.ZodArray<z.ZodString>;
+  }, z.core.$strip>;
+}, z.core.$strip>;
+type ConversationHistorySummary = z.infer<typeof ConversationHistorySummarySchema>;
+/**
+ * Distill entire conversation history into a comprehensive summary that can replace the full message history
+ */
+declare function distillConversationHistory(params: {
+  messages: any[];
+  conversationId: string;
+  summarizerModel: ModelSettings;
+  toolCallToArtifactMap?: Record<string, string>;
+}): Promise<ConversationHistorySummary>;
+//#endregion
+export { ConversationHistorySummary, ConversationHistorySummarySchema, distillConversationHistory };

package/dist/tools/distill-conversation-history-tool.js

@@ -0,0 +1,206 @@
+import { getLogger } from "../logger.js";
+import { ModelFactory } from "@inkeep/agents-core";
+import { Output, generateText } from "ai";
+import { z } from "zod";
+
+//#region src/tools/distill-conversation-history-tool.ts
+const logger = getLogger("distill-conversation-history-tool");
+/**
+* Conversation History Summary Schema - structured object for replacing entire conversation histories
+*/
+const ConversationHistorySummarySchema = z.object({
+	type: z.literal("conversation_history_summary_v1"),
+	session_id: z.string().nullable().optional(),
+	conversation_overview: z.string().describe("2-4 sentences capturing the full conversation context and what was accomplished"),
+	user_goals: z.object({
+		primary: z.string().describe("Main objective the user was trying to achieve"),
+		secondary: z.array(z.string()).describe("Additional goals or tasks that emerged during conversation")
+	}),
+	key_outcomes: z.object({
+		completed: z.array(z.string()).describe("Tasks, questions, or problems that were fully resolved"),
+		partial: z.array(z.string()).describe("Work that was started but not completed"),
+		discoveries: z.array(z.string()).describe("Important information, insights, or findings uncovered")
+	}),
+	technical_context: z.object({
+		technologies: z.array(z.string()).describe("Relevant technologies, frameworks, tools mentioned"),
+		configurations: z.array(z.string()).describe("Settings, parameters, or configurations discussed"),
+		issues_encountered: z.array(z.string()).describe("Problems, errors, or challenges that came up"),
+		solutions_applied: z.array(z.string()).describe("Fixes, workarounds, or solutions that were implemented")
+	}),
+	conversation_artifacts: z.array(z.object({
+		id: z.string().describe("Artifact ID"),
+		name: z.string().describe("Human-readable name describing the content"),
+		tool_name: z.string().describe("Tool that generated this artifact"),
+		tool_call_id: z.string().describe("Specific tool call ID for precise referencing"),
+		content_summary: z.string().describe("Brief summary of what this artifact contains"),
+		relevance: z.enum([
+			"high",
+			"medium",
+			"low"
+		]).describe("Importance of this artifact to the overall conversation")
+	})).optional().describe("All artifacts referenced in this conversation with their significance"),
+	conversation_flow: z.object({
+		major_phases: z.array(z.string()).describe("Main phases or stages the conversation went through"),
+		decision_points: z.array(z.string()).describe("Key decisions made during the conversation"),
+		topic_shifts: z.array(z.string()).describe("When and why the conversation changed direction")
+	}),
+	context_for_continuation: z.object({
+		current_state: z.string().describe("Where things stand now - current status or position"),
+		next_logical_steps: z.array(z.string()).describe("What should naturally happen next based on conversation"),
+		important_context: z.array(z.string()).describe("Critical background info needed for future interactions")
+	})
+});
+/**
+* Distill entire conversation history into a comprehensive summary that can replace the full message history
+*/
+async function distillConversationHistory(params) {
+	const { messages, conversationId, summarizerModel, toolCallToArtifactMap } = params;
+	try {
+		if (!summarizerModel?.model?.trim()) throw new Error("Summarizer model is required");
+		const { output: summary } = await generateText({
+			model: ModelFactory.createModel(summarizerModel),
+			prompt: `You are a conversation history summarization assistant. Your job is to create a comprehensive summary that can COMPLETELY REPLACE the original conversation history while preserving all essential context.
+
+**Complete Conversation to Summarize:**
+
+\`\`\`text
+${messages.map((msg) => {
+				const parts = [];
+				if (typeof msg.content === "string") parts.push(msg.content);
+				else if (Array.isArray(msg.content)) {
+					for (const block of msg.content) if (block.type === "text") parts.push(block.text);
+					else if (block.type === "tool-call") parts.push(`[TOOL CALL] ${block.toolName}(${JSON.stringify(block.input)}) [ID: ${block.toolCallId}]`);
+					else if (block.type === "tool-result") {
+						const artifactId = toolCallToArtifactMap?.[block.toolCallId];
+						const artifactInfo = artifactId ? `\n[ARTIFACT CREATED: ${artifactId}]` : "";
+						parts.push(`[TOOL RESULT] ${block.toolName} [ID: ${block.toolCallId}]${artifactInfo}\nResult: ${JSON.stringify(block.result)}`);
+					}
+				} else if (msg.content?.text) parts.push(msg.content.text);
+				return parts.length > 0 ? `${msg.role || "system"}: ${parts.join("\n")}` : "";
+			}).filter((line) => line.trim().length > 0).join("\n\n")}
+\`\`\`
+
+Create a comprehensive summary using this exact JSON schema:
+
+\`\`\`json
+{
+  "type": "conversation_history_summary_v1",
+  "session_id": "<conversationId>",
+  "conversation_overview": "<2-4 sentences capturing full context and accomplishments>",
+  "user_goals": {
+    "primary": "<main objective user was trying to achieve>",
+    "secondary": ["<additional goals that emerged>"]
+  },
+  "key_outcomes": {
+    "completed": ["<tasks/questions fully resolved>"],
+    "partial": ["<work started but not completed>"],
+    "discoveries": ["<important findings uncovered>"]
+  },
+  "technical_context": {
+    "technologies": ["<relevant tech/frameworks/tools>"],
+    "configurations": ["<settings/parameters discussed>"],
+    "issues_encountered": ["<problems/errors that came up>"],
+    "solutions_applied": ["<fixes/workarounds implemented>"]
+  },
+  "conversation_artifacts": [
+    {
+      "id": "<artifact_id>",
+      "name": "<descriptive name>",
+      "tool_name": "<tool_name>",
+      "tool_call_id": "<tool_call_id>",
+      "content_summary": "<what this artifact contains>",
+      "relevance": "<high|medium|low>"
+    }
+  ],
+  "conversation_flow": {
+    "major_phases": ["<main stages conversation went through>"],
+    "decision_points": ["<key decisions made>"],
+    "topic_shifts": ["<when/why conversation changed direction>"]
+  },
+  "context_for_continuation": {
+    "current_state": "<where things stand now>",
+    "next_logical_steps": ["<what should happen next>"],
+    "important_context": ["<critical background for future interactions>"]
+  }
+}
+\`\`\`
+
+**CRITICAL RULES - COMPREHENSIVE HISTORICAL PRESERVATION:**
+
+🎯 **COMPLETE CONTEXT CAPTURE**: This summary must contain ALL information needed to continue the conversation as if the full history was available
+
+🎯 **PRESERVE OUTCOMES**: Document everything that was accomplished, learned, discovered, or decided
+
+🎯 **TECHNICAL PRECISION**: Include specific technologies, configurations, error messages, solutions - technical details matter
+
+🎯 **ARTIFACT COMPLETENESS**: Reference ALL artifacts with clear descriptions of their contents and importance
+
+🎯 **CONVERSATION NARRATIVE**: Capture the logical flow - how did we get from start to current state?
+
+🎯 **CONTINUATION CONTEXT**: Provide everything needed for smooth conversation continuation
+
+🎯 **NO OPERATIONAL DETAILS**: Focus on WHAT was accomplished, not HOW (tools used, compression, etc.)
+
+🎯 **HANDLE TRANSFERS SIMPLY**: Agent transfers/delegations are just routing - don't look for reasons or justifications. Simply note "conversation transferred to [specialist]" if relevant to context.
+
+**Examples of GOOD content:**
+✅ "User was implementing OAuth2 authentication in React app using Auth0, encountered CORS errors on localhost:3000, resolved by adding domain to Auth0 dashboard allowed origins"
+✅ "Discovered that the API supports both REST and GraphQL endpoints, with GraphQL providing better performance for complex queries"
+✅ "Configured webpack dev server with proxy settings to handle API calls during development"
+✅ "Conversation transferred to QA specialist to handle testing questions"
+
+**Examples of BAD content:**
+❌ "Assistant used search tool to find information"
+❌ "Multiple tool calls were made"
+❌ "Artifacts were created for reference"
+❌ "Assistant needed to transfer because user required specialized help" (don't invent reasons for transfers)
+
+**REMEMBER**: This summary is REPLACING the entire conversation history. Include everything essential for context continuation.
+
+Return **only** valid JSON.`,
+			output: Output.object({ schema: ConversationHistorySummarySchema })
+		});
+		summary.session_id = conversationId;
+		return summary;
+	} catch (error) {
+		logger.error({
+			conversationId,
+			messageCount: messages.length,
+			error: error instanceof Error ? error.message : "Unknown error"
+		}, "Failed to distill conversation history");
+		return {
+			type: "conversation_history_summary_v1",
+			session_id: conversationId,
+			conversation_overview: "Conversation session with technical discussion and problem-solving",
+			user_goals: {
+				primary: "Technical assistance and problem-solving",
+				secondary: []
+			},
+			key_outcomes: {
+				completed: [],
+				partial: ["Ongoing technical work"],
+				discoveries: []
+			},
+			technical_context: {
+				technologies: [],
+				configurations: [],
+				issues_encountered: [],
+				solutions_applied: []
+			},
+			conversation_artifacts: [],
+			conversation_flow: {
+				major_phases: ["Initial discussion", "Technical exploration"],
+				decision_points: [],
+				topic_shifts: []
+			},
+			context_for_continuation: {
+				current_state: "In progress - technical work ongoing",
+				next_logical_steps: ["Continue with current technical objectives"],
+				important_context: ["Review previous discussion for technical context"]
+			}
+		};
+	}
+}
+
+//#endregion
+export { ConversationHistorySummarySchema, distillConversationHistory };

package/dist/tools/distill-conversation-tool.d.ts

@@ -0,0 +1,41 @@
+import { ModelSettings } from "@inkeep/agents-core";
+import { z } from "zod";
+
+//#region src/tools/distill-conversation-tool.d.ts
+
+/**
+ * Conversation Summary Schema - structured object for maintaining conversation context
+ */
+declare const ConversationSummarySchema: z.ZodObject<{
+  type: z.ZodLiteral<"conversation_summary_v1">;
+  session_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+  high_level: z.ZodString;
+  user_intent: z.ZodString;
+  decisions: z.ZodArray<z.ZodString>;
+  open_questions: z.ZodArray<z.ZodString>;
+  next_steps: z.ZodObject<{
+    for_agent: z.ZodArray<z.ZodString>;
+    for_user: z.ZodArray<z.ZodString>;
+  }, z.core.$strip>;
+  related_artifacts: z.ZodOptional<z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    tool_name: z.ZodString;
+    tool_call_id: z.ZodString;
+    content_type: z.ZodString;
+    key_findings: z.ZodArray<z.ZodString>;
+  }, z.core.$strip>>>;
+}, z.core.$strip>;
+type ConversationSummary = z.infer<typeof ConversationSummarySchema>;
+/**
+ * Core conversation distillation - takes messages and creates structured summary
+ */
+declare function distillConversation(params: {
+  messages: any[];
+  conversationId: string;
+  currentSummary?: ConversationSummary | null;
+  summarizerModel?: ModelSettings;
+  toolCallToArtifactMap?: Record<string, string>;
+}): Promise<ConversationSummary>;
+//#endregion
+export { ConversationSummary, ConversationSummarySchema, distillConversation };