@inkeep/agents-run-api 0.0.0-dev-20260105192809 → 0.0.0-dev-20260105194521

package/dist/agents/generateTaskHandler.js

@@ -11,6 +11,7 @@ import { TaskState, dbResultToMcpTool, generateId, getAgentById, getAgentWithDef
 const logger = getLogger("generateTaskHandler");
 const createTaskHandler = (config, credentialStoreRegistry) => {
 	return async (task) => {
+		let agent;
 		try {
 			const userMessage = task.input.parts.filter((part) => part.text).map((part) => part.text).join(" ");
 			if (!userMessage.trim()) return {
@@ -161,7 +162,7 @@ const createTaskHandler = (config, credentialStoreRegistry) => {
 				}
 				return mcpTool;
 			})) ?? [];
-			const agent = new Agent({
+			agent = new Agent({
 				id: config.subAgentId,
 				tenantId: config.tenantId,
 				projectId: config.projectId,
@@ -360,6 +361,7 @@ const createTaskHandler = (config, credentialStoreRegistry) => {
 					...config.apiKey ? { apiKey: config.apiKey } : {}
 				}
 			});
+			agent.cleanupCompression();
 			const stepContents = response.steps && Array.isArray(response.steps) ? response.steps.flatMap((step) => {
 				return step.content && Array.isArray(step.content) ? step.content : [];
 			}) : [];
@@ -410,7 +412,8 @@ const createTaskHandler = (config, credentialStoreRegistry) => {
 								parts: [{
 									kind: "data",
 									data: artifactData
-								}]
+								}],
+								createdAt: (/* @__PURE__ */ new Date()).toISOString()
 							}]
 						};
 					}
@@ -431,11 +434,17 @@ const createTaskHandler = (config, credentialStoreRegistry) => {
 				status: { state: TaskState.Completed },
 				artifacts: [{
 					artifactId: generateId(),
-					parts
+					parts,
+					createdAt: (/* @__PURE__ */ new Date()).toISOString()
 				}]
 			};
 		} catch (error) {
 			console.error("Task handler error:", error);
+			try {
+				if (agent) agent.cleanupCompression();
+			} catch (cleanupError) {
+				logger.warn({ cleanupError }, "Failed to cleanup agent compression on error");
+			}
 			const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";
 			const isConnectionRefused = errorMessage.includes("Connection refused. Please check if the MCP server is running.");
 			return {

package/dist/constants/execution-limits/defaults.d.ts

@@ -42,6 +42,10 @@ declare const executionLimitsDefaults: {
   readonly STREAM_TEXT_GAP_THRESHOLD_MS: 2000;
   readonly STREAM_MAX_LIFETIME_MS: 600000;
   readonly CONVERSATION_HISTORY_DEFAULT_LIMIT: 50;
+  readonly CONVERSATION_ARTIFACTS_LIMIT: 12;
+  readonly COMPRESSION_HARD_LIMIT: 120000;
+  readonly COMPRESSION_SAFETY_BUFFER: 20000;
+  readonly COMPRESSION_ENABLED: true;
 };
 //#endregion
 export { executionLimitsDefaults };

package/dist/constants/execution-limits/defaults.js

@@ -41,7 +41,11 @@ const executionLimitsDefaults = {
 	STREAM_BUFFER_MAX_SIZE_BYTES: 5242880,
 	STREAM_TEXT_GAP_THRESHOLD_MS: 2e3,
 	STREAM_MAX_LIFETIME_MS: 6e5,
-	CONVERSATION_HISTORY_DEFAULT_LIMIT: 50
+	CONVERSATION_HISTORY_DEFAULT_LIMIT: 50,
+	CONVERSATION_ARTIFACTS_LIMIT: 12,
+	COMPRESSION_HARD_LIMIT: 12e4,
+	COMPRESSION_SAFETY_BUFFER: 2e4,
+	COMPRESSION_ENABLED: true
 };
 
 //#endregion

package/dist/constants/execution-limits/index.d.ts

@@ -1,6 +1,6 @@
 import { executionLimitsDefaults } from "./defaults.js";
 
 //#region src/constants/execution-limits/index.d.ts
-declare const AGENT_EXECUTION_MAX_CONSECUTIVE_ERRORS: 3, AGENT_EXECUTION_MAX_GENERATION_STEPS: 5, LLM_GENERATION_FIRST_CALL_TIMEOUT_MS_STREAMING: 270000, LLM_GENERATION_FIRST_CALL_TIMEOUT_MS_NON_STREAMING: 90000, LLM_GENERATION_SUBSEQUENT_CALL_TIMEOUT_MS: 90000, LLM_GENERATION_MAX_ALLOWED_TIMEOUT_MS: 600000, FUNCTION_TOOL_EXECUTION_TIMEOUT_MS_DEFAULT: 30000, FUNCTION_TOOL_SANDBOX_VCPUS_DEFAULT: 4, FUNCTION_TOOL_SANDBOX_POOL_TTL_MS: 300000, FUNCTION_TOOL_SANDBOX_MAX_USE_COUNT: 50, FUNCTION_TOOL_SANDBOX_MAX_OUTPUT_SIZE_BYTES: 1048576, FUNCTION_TOOL_SANDBOX_QUEUE_WAIT_TIMEOUT_MS: 30000, FUNCTION_TOOL_SANDBOX_CLEANUP_INTERVAL_MS: 60000, MCP_TOOL_REQUEST_TIMEOUT_MS_DEFAULT: 60000, DELEGATION_TOOL_BACKOFF_INITIAL_INTERVAL_MS: 100, DELEGATION_TOOL_BACKOFF_MAX_INTERVAL_MS: 10000, DELEGATION_TOOL_BACKOFF_EXPONENT: 2, DELEGATION_TOOL_BACKOFF_MAX_ELAPSED_TIME_MS: 20000, A2A_BACKOFF_INITIAL_INTERVAL_MS: 500, A2A_BACKOFF_MAX_INTERVAL_MS: 60000, A2A_BACKOFF_EXPONENT: 1.5, A2A_BACKOFF_MAX_ELAPSED_TIME_MS: 30000, ARTIFACT_GENERATION_MAX_RETRIES: 3, ARTIFACT_SESSION_MAX_PENDING: 100, ARTIFACT_SESSION_MAX_PREVIOUS_SUMMARIES: 3, ARTIFACT_GENERATION_BACKOFF_INITIAL_MS: 1000, ARTIFACT_GENERATION_BACKOFF_MAX_MS: 10000, SESSION_TOOL_RESULT_CACHE_TIMEOUT_MS: 300000, SESSION_CLEANUP_INTERVAL_MS: 60000, STATUS_UPDATE_DEFAULT_NUM_EVENTS: 1, STATUS_UPDATE_DEFAULT_INTERVAL_SECONDS: 2, STREAM_PARSER_MAX_SNAPSHOT_SIZE: 100, STREAM_PARSER_MAX_STREAMED_SIZE: 1000, STREAM_PARSER_MAX_COLLECTED_PARTS: 10000, STREAM_BUFFER_MAX_SIZE_BYTES: 5242880, STREAM_TEXT_GAP_THRESHOLD_MS: 2000, STREAM_MAX_LIFETIME_MS: 600000, CONVERSATION_HISTORY_DEFAULT_LIMIT: 50;
+declare const AGENT_EXECUTION_MAX_CONSECUTIVE_ERRORS: 3, AGENT_EXECUTION_MAX_GENERATION_STEPS: 5, LLM_GENERATION_FIRST_CALL_TIMEOUT_MS_STREAMING: 270000, LLM_GENERATION_FIRST_CALL_TIMEOUT_MS_NON_STREAMING: 90000, LLM_GENERATION_SUBSEQUENT_CALL_TIMEOUT_MS: 90000, LLM_GENERATION_MAX_ALLOWED_TIMEOUT_MS: 600000, FUNCTION_TOOL_EXECUTION_TIMEOUT_MS_DEFAULT: 30000, FUNCTION_TOOL_SANDBOX_VCPUS_DEFAULT: 4, FUNCTION_TOOL_SANDBOX_POOL_TTL_MS: 300000, FUNCTION_TOOL_SANDBOX_MAX_USE_COUNT: 50, FUNCTION_TOOL_SANDBOX_MAX_OUTPUT_SIZE_BYTES: 1048576, FUNCTION_TOOL_SANDBOX_QUEUE_WAIT_TIMEOUT_MS: 30000, FUNCTION_TOOL_SANDBOX_CLEANUP_INTERVAL_MS: 60000, MCP_TOOL_REQUEST_TIMEOUT_MS_DEFAULT: 60000, DELEGATION_TOOL_BACKOFF_INITIAL_INTERVAL_MS: 100, DELEGATION_TOOL_BACKOFF_MAX_INTERVAL_MS: 10000, DELEGATION_TOOL_BACKOFF_EXPONENT: 2, DELEGATION_TOOL_BACKOFF_MAX_ELAPSED_TIME_MS: 20000, A2A_BACKOFF_INITIAL_INTERVAL_MS: 500, A2A_BACKOFF_MAX_INTERVAL_MS: 60000, A2A_BACKOFF_EXPONENT: 1.5, A2A_BACKOFF_MAX_ELAPSED_TIME_MS: 30000, ARTIFACT_GENERATION_MAX_RETRIES: 3, ARTIFACT_SESSION_MAX_PENDING: 100, ARTIFACT_SESSION_MAX_PREVIOUS_SUMMARIES: 3, ARTIFACT_GENERATION_BACKOFF_INITIAL_MS: 1000, ARTIFACT_GENERATION_BACKOFF_MAX_MS: 10000, SESSION_TOOL_RESULT_CACHE_TIMEOUT_MS: 300000, SESSION_CLEANUP_INTERVAL_MS: 60000, STATUS_UPDATE_DEFAULT_NUM_EVENTS: 1, STATUS_UPDATE_DEFAULT_INTERVAL_SECONDS: 2, STREAM_PARSER_MAX_SNAPSHOT_SIZE: 100, STREAM_PARSER_MAX_STREAMED_SIZE: 1000, STREAM_PARSER_MAX_COLLECTED_PARTS: 10000, STREAM_BUFFER_MAX_SIZE_BYTES: 5242880, STREAM_TEXT_GAP_THRESHOLD_MS: 2000, STREAM_MAX_LIFETIME_MS: 600000, CONVERSATION_HISTORY_DEFAULT_LIMIT: 50, CONVERSATION_ARTIFACTS_LIMIT: 12, COMPRESSION_HARD_LIMIT: 120000, COMPRESSION_SAFETY_BUFFER: 20000, COMPRESSION_ENABLED: true;
 //#endregion
-export { A2A_BACKOFF_EXPONENT, A2A_BACKOFF_INITIAL_INTERVAL_MS, A2A_BACKOFF_MAX_ELAPSED_TIME_MS, A2A_BACKOFF_MAX_INTERVAL_MS, AGENT_EXECUTION_MAX_CONSECUTIVE_ERRORS, AGENT_EXECUTION_MAX_GENERATION_STEPS, ARTIFACT_GENERATION_BACKOFF_INITIAL_MS, ARTIFACT_GENERATION_BACKOFF_MAX_MS, ARTIFACT_GENERATION_MAX_RETRIES, ARTIFACT_SESSION_MAX_PENDING, ARTIFACT_SESSION_MAX_PREVIOUS_SUMMARIES, CONVERSATION_HISTORY_DEFAULT_LIMIT, DELEGATION_TOOL_BACKOFF_EXPONENT, DELEGATION_TOOL_BACKOFF_INITIAL_INTERVAL_MS, DELEGATION_TOOL_BACKOFF_MAX_ELAPSED_TIME_MS, DELEGATION_TOOL_BACKOFF_MAX_INTERVAL_MS, FUNCTION_TOOL_EXECUTION_TIMEOUT_MS_DEFAULT, FUNCTION_TOOL_SANDBOX_CLEANUP_INTERVAL_MS, FUNCTION_TOOL_SANDBOX_MAX_OUTPUT_SIZE_BYTES, FUNCTION_TOOL_SANDBOX_MAX_USE_COUNT, FUNCTION_TOOL_SANDBOX_POOL_TTL_MS, FUNCTION_TOOL_SANDBOX_QUEUE_WAIT_TIMEOUT_MS, FUNCTION_TOOL_SANDBOX_VCPUS_DEFAULT, LLM_GENERATION_FIRST_CALL_TIMEOUT_MS_NON_STREAMING, LLM_GENERATION_FIRST_CALL_TIMEOUT_MS_STREAMING, LLM_GENERATION_MAX_ALLOWED_TIMEOUT_MS, LLM_GENERATION_SUBSEQUENT_CALL_TIMEOUT_MS, MCP_TOOL_REQUEST_TIMEOUT_MS_DEFAULT, SESSION_CLEANUP_INTERVAL_MS, SESSION_TOOL_RESULT_CACHE_TIMEOUT_MS, STATUS_UPDATE_DEFAULT_INTERVAL_SECONDS, STATUS_UPDATE_DEFAULT_NUM_EVENTS, STREAM_BUFFER_MAX_SIZE_BYTES, STREAM_MAX_LIFETIME_MS, STREAM_PARSER_MAX_COLLECTED_PARTS, STREAM_PARSER_MAX_SNAPSHOT_SIZE, STREAM_PARSER_MAX_STREAMED_SIZE, STREAM_TEXT_GAP_THRESHOLD_MS, executionLimitsDefaults };
+export { A2A_BACKOFF_EXPONENT, A2A_BACKOFF_INITIAL_INTERVAL_MS, A2A_BACKOFF_MAX_ELAPSED_TIME_MS, A2A_BACKOFF_MAX_INTERVAL_MS, AGENT_EXECUTION_MAX_CONSECUTIVE_ERRORS, AGENT_EXECUTION_MAX_GENERATION_STEPS, ARTIFACT_GENERATION_BACKOFF_INITIAL_MS, ARTIFACT_GENERATION_BACKOFF_MAX_MS, ARTIFACT_GENERATION_MAX_RETRIES, ARTIFACT_SESSION_MAX_PENDING, ARTIFACT_SESSION_MAX_PREVIOUS_SUMMARIES, COMPRESSION_ENABLED, COMPRESSION_HARD_LIMIT, COMPRESSION_SAFETY_BUFFER, CONVERSATION_ARTIFACTS_LIMIT, CONVERSATION_HISTORY_DEFAULT_LIMIT, DELEGATION_TOOL_BACKOFF_EXPONENT, DELEGATION_TOOL_BACKOFF_INITIAL_INTERVAL_MS, DELEGATION_TOOL_BACKOFF_MAX_ELAPSED_TIME_MS, DELEGATION_TOOL_BACKOFF_MAX_INTERVAL_MS, FUNCTION_TOOL_EXECUTION_TIMEOUT_MS_DEFAULT, FUNCTION_TOOL_SANDBOX_CLEANUP_INTERVAL_MS, FUNCTION_TOOL_SANDBOX_MAX_OUTPUT_SIZE_BYTES, FUNCTION_TOOL_SANDBOX_MAX_USE_COUNT, FUNCTION_TOOL_SANDBOX_POOL_TTL_MS, FUNCTION_TOOL_SANDBOX_QUEUE_WAIT_TIMEOUT_MS, FUNCTION_TOOL_SANDBOX_VCPUS_DEFAULT, LLM_GENERATION_FIRST_CALL_TIMEOUT_MS_NON_STREAMING, LLM_GENERATION_FIRST_CALL_TIMEOUT_MS_STREAMING, LLM_GENERATION_MAX_ALLOWED_TIMEOUT_MS, LLM_GENERATION_SUBSEQUENT_CALL_TIMEOUT_MS, MCP_TOOL_REQUEST_TIMEOUT_MS_DEFAULT, SESSION_CLEANUP_INTERVAL_MS, SESSION_TOOL_RESULT_CACHE_TIMEOUT_MS, STATUS_UPDATE_DEFAULT_INTERVAL_SECONDS, STATUS_UPDATE_DEFAULT_NUM_EVENTS, STREAM_BUFFER_MAX_SIZE_BYTES, STREAM_MAX_LIFETIME_MS, STREAM_PARSER_MAX_COLLECTED_PARTS, STREAM_PARSER_MAX_SNAPSHOT_SIZE, STREAM_PARSER_MAX_STREAMED_SIZE, STREAM_TEXT_GAP_THRESHOLD_MS, executionLimitsDefaults };

package/dist/constants/execution-limits/index.js

@@ -4,13 +4,18 @@ import { loadEnvironmentFiles } from "@inkeep/agents-core";
 
 //#region src/constants/execution-limits/index.ts
 loadEnvironmentFiles();
-const constantsSchema = z.object(Object.fromEntries(Object.keys(executionLimitsDefaults).map((key) => [`AGENTS_${key}`, z.coerce.number().optional()])));
+const constantsSchema = z.object(Object.fromEntries(Object.keys(executionLimitsDefaults).map((key) => {
+	const defaultValue = executionLimitsDefaults[key];
+	const envKey = `AGENTS_${key}`;
+	if (typeof defaultValue === "boolean") return [envKey, z.coerce.boolean().optional()];
+	else return [envKey, z.coerce.number().optional()];
+})));
 const parseConstants = () => {
 	const envOverrides = constantsSchema.parse(process.env);
 	return Object.fromEntries(Object.entries(executionLimitsDefaults).map(([key, defaultValue]) => [key, envOverrides[`AGENTS_${key}`] ?? defaultValue]));
 };
 const constants = parseConstants();
-const { AGENT_EXECUTION_MAX_CONSECUTIVE_ERRORS, AGENT_EXECUTION_MAX_GENERATION_STEPS, LLM_GENERATION_FIRST_CALL_TIMEOUT_MS_STREAMING, LLM_GENERATION_FIRST_CALL_TIMEOUT_MS_NON_STREAMING, LLM_GENERATION_SUBSEQUENT_CALL_TIMEOUT_MS, LLM_GENERATION_MAX_ALLOWED_TIMEOUT_MS, FUNCTION_TOOL_EXECUTION_TIMEOUT_MS_DEFAULT, FUNCTION_TOOL_SANDBOX_VCPUS_DEFAULT, FUNCTION_TOOL_SANDBOX_POOL_TTL_MS, FUNCTION_TOOL_SANDBOX_MAX_USE_COUNT, FUNCTION_TOOL_SANDBOX_MAX_OUTPUT_SIZE_BYTES, FUNCTION_TOOL_SANDBOX_QUEUE_WAIT_TIMEOUT_MS, FUNCTION_TOOL_SANDBOX_CLEANUP_INTERVAL_MS, MCP_TOOL_REQUEST_TIMEOUT_MS_DEFAULT, DELEGATION_TOOL_BACKOFF_INITIAL_INTERVAL_MS, DELEGATION_TOOL_BACKOFF_MAX_INTERVAL_MS, DELEGATION_TOOL_BACKOFF_EXPONENT, DELEGATION_TOOL_BACKOFF_MAX_ELAPSED_TIME_MS, A2A_BACKOFF_INITIAL_INTERVAL_MS, A2A_BACKOFF_MAX_INTERVAL_MS, A2A_BACKOFF_EXPONENT, A2A_BACKOFF_MAX_ELAPSED_TIME_MS, ARTIFACT_GENERATION_MAX_RETRIES, ARTIFACT_SESSION_MAX_PENDING, ARTIFACT_SESSION_MAX_PREVIOUS_SUMMARIES, ARTIFACT_GENERATION_BACKOFF_INITIAL_MS, ARTIFACT_GENERATION_BACKOFF_MAX_MS, SESSION_TOOL_RESULT_CACHE_TIMEOUT_MS, SESSION_CLEANUP_INTERVAL_MS, STATUS_UPDATE_DEFAULT_NUM_EVENTS, STATUS_UPDATE_DEFAULT_INTERVAL_SECONDS, STREAM_PARSER_MAX_SNAPSHOT_SIZE, STREAM_PARSER_MAX_STREAMED_SIZE, STREAM_PARSER_MAX_COLLECTED_PARTS, STREAM_BUFFER_MAX_SIZE_BYTES, STREAM_TEXT_GAP_THRESHOLD_MS, STREAM_MAX_LIFETIME_MS, CONVERSATION_HISTORY_DEFAULT_LIMIT } = constants;
+const { AGENT_EXECUTION_MAX_CONSECUTIVE_ERRORS, AGENT_EXECUTION_MAX_GENERATION_STEPS, LLM_GENERATION_FIRST_CALL_TIMEOUT_MS_STREAMING, LLM_GENERATION_FIRST_CALL_TIMEOUT_MS_NON_STREAMING, LLM_GENERATION_SUBSEQUENT_CALL_TIMEOUT_MS, LLM_GENERATION_MAX_ALLOWED_TIMEOUT_MS, FUNCTION_TOOL_EXECUTION_TIMEOUT_MS_DEFAULT, FUNCTION_TOOL_SANDBOX_VCPUS_DEFAULT, FUNCTION_TOOL_SANDBOX_POOL_TTL_MS, FUNCTION_TOOL_SANDBOX_MAX_USE_COUNT, FUNCTION_TOOL_SANDBOX_MAX_OUTPUT_SIZE_BYTES, FUNCTION_TOOL_SANDBOX_QUEUE_WAIT_TIMEOUT_MS, FUNCTION_TOOL_SANDBOX_CLEANUP_INTERVAL_MS, MCP_TOOL_REQUEST_TIMEOUT_MS_DEFAULT, DELEGATION_TOOL_BACKOFF_INITIAL_INTERVAL_MS, DELEGATION_TOOL_BACKOFF_MAX_INTERVAL_MS, DELEGATION_TOOL_BACKOFF_EXPONENT, DELEGATION_TOOL_BACKOFF_MAX_ELAPSED_TIME_MS, A2A_BACKOFF_INITIAL_INTERVAL_MS, A2A_BACKOFF_MAX_INTERVAL_MS, A2A_BACKOFF_EXPONENT, A2A_BACKOFF_MAX_ELAPSED_TIME_MS, ARTIFACT_GENERATION_MAX_RETRIES, ARTIFACT_SESSION_MAX_PENDING, ARTIFACT_SESSION_MAX_PREVIOUS_SUMMARIES, ARTIFACT_GENERATION_BACKOFF_INITIAL_MS, ARTIFACT_GENERATION_BACKOFF_MAX_MS, SESSION_TOOL_RESULT_CACHE_TIMEOUT_MS, SESSION_CLEANUP_INTERVAL_MS, STATUS_UPDATE_DEFAULT_NUM_EVENTS, STATUS_UPDATE_DEFAULT_INTERVAL_SECONDS, STREAM_PARSER_MAX_SNAPSHOT_SIZE, STREAM_PARSER_MAX_STREAMED_SIZE, STREAM_PARSER_MAX_COLLECTED_PARTS, STREAM_BUFFER_MAX_SIZE_BYTES, STREAM_TEXT_GAP_THRESHOLD_MS, STREAM_MAX_LIFETIME_MS, CONVERSATION_HISTORY_DEFAULT_LIMIT, CONVERSATION_ARTIFACTS_LIMIT, COMPRESSION_HARD_LIMIT, COMPRESSION_SAFETY_BUFFER, COMPRESSION_ENABLED } = constants;
 
 //#endregion
-export { A2A_BACKOFF_EXPONENT, A2A_BACKOFF_INITIAL_INTERVAL_MS, A2A_BACKOFF_MAX_ELAPSED_TIME_MS, A2A_BACKOFF_MAX_INTERVAL_MS, AGENT_EXECUTION_MAX_CONSECUTIVE_ERRORS, AGENT_EXECUTION_MAX_GENERATION_STEPS, ARTIFACT_GENERATION_BACKOFF_INITIAL_MS, ARTIFACT_GENERATION_BACKOFF_MAX_MS, ARTIFACT_GENERATION_MAX_RETRIES, ARTIFACT_SESSION_MAX_PENDING, ARTIFACT_SESSION_MAX_PREVIOUS_SUMMARIES, CONVERSATION_HISTORY_DEFAULT_LIMIT, DELEGATION_TOOL_BACKOFF_EXPONENT, DELEGATION_TOOL_BACKOFF_INITIAL_INTERVAL_MS, DELEGATION_TOOL_BACKOFF_MAX_ELAPSED_TIME_MS, DELEGATION_TOOL_BACKOFF_MAX_INTERVAL_MS, FUNCTION_TOOL_EXECUTION_TIMEOUT_MS_DEFAULT, FUNCTION_TOOL_SANDBOX_CLEANUP_INTERVAL_MS, FUNCTION_TOOL_SANDBOX_MAX_OUTPUT_SIZE_BYTES, FUNCTION_TOOL_SANDBOX_MAX_USE_COUNT, FUNCTION_TOOL_SANDBOX_POOL_TTL_MS, FUNCTION_TOOL_SANDBOX_QUEUE_WAIT_TIMEOUT_MS, FUNCTION_TOOL_SANDBOX_VCPUS_DEFAULT, LLM_GENERATION_FIRST_CALL_TIMEOUT_MS_NON_STREAMING, LLM_GENERATION_FIRST_CALL_TIMEOUT_MS_STREAMING, LLM_GENERATION_MAX_ALLOWED_TIMEOUT_MS, LLM_GENERATION_SUBSEQUENT_CALL_TIMEOUT_MS, MCP_TOOL_REQUEST_TIMEOUT_MS_DEFAULT, SESSION_CLEANUP_INTERVAL_MS, SESSION_TOOL_RESULT_CACHE_TIMEOUT_MS, STATUS_UPDATE_DEFAULT_INTERVAL_SECONDS, STATUS_UPDATE_DEFAULT_NUM_EVENTS, STREAM_BUFFER_MAX_SIZE_BYTES, STREAM_MAX_LIFETIME_MS, STREAM_PARSER_MAX_COLLECTED_PARTS, STREAM_PARSER_MAX_SNAPSHOT_SIZE, STREAM_PARSER_MAX_STREAMED_SIZE, STREAM_TEXT_GAP_THRESHOLD_MS, executionLimitsDefaults };
+export { A2A_BACKOFF_EXPONENT, A2A_BACKOFF_INITIAL_INTERVAL_MS, A2A_BACKOFF_MAX_ELAPSED_TIME_MS, A2A_BACKOFF_MAX_INTERVAL_MS, AGENT_EXECUTION_MAX_CONSECUTIVE_ERRORS, AGENT_EXECUTION_MAX_GENERATION_STEPS, ARTIFACT_GENERATION_BACKOFF_INITIAL_MS, ARTIFACT_GENERATION_BACKOFF_MAX_MS, ARTIFACT_GENERATION_MAX_RETRIES, ARTIFACT_SESSION_MAX_PENDING, ARTIFACT_SESSION_MAX_PREVIOUS_SUMMARIES, COMPRESSION_ENABLED, COMPRESSION_HARD_LIMIT, COMPRESSION_SAFETY_BUFFER, CONVERSATION_ARTIFACTS_LIMIT, CONVERSATION_HISTORY_DEFAULT_LIMIT, DELEGATION_TOOL_BACKOFF_EXPONENT, DELEGATION_TOOL_BACKOFF_INITIAL_INTERVAL_MS, DELEGATION_TOOL_BACKOFF_MAX_ELAPSED_TIME_MS, DELEGATION_TOOL_BACKOFF_MAX_INTERVAL_MS, FUNCTION_TOOL_EXECUTION_TIMEOUT_MS_DEFAULT, FUNCTION_TOOL_SANDBOX_CLEANUP_INTERVAL_MS, FUNCTION_TOOL_SANDBOX_MAX_OUTPUT_SIZE_BYTES, FUNCTION_TOOL_SANDBOX_MAX_USE_COUNT, FUNCTION_TOOL_SANDBOX_POOL_TTL_MS, FUNCTION_TOOL_SANDBOX_QUEUE_WAIT_TIMEOUT_MS, FUNCTION_TOOL_SANDBOX_VCPUS_DEFAULT, LLM_GENERATION_FIRST_CALL_TIMEOUT_MS_NON_STREAMING, LLM_GENERATION_FIRST_CALL_TIMEOUT_MS_STREAMING, LLM_GENERATION_MAX_ALLOWED_TIMEOUT_MS, LLM_GENERATION_SUBSEQUENT_CALL_TIMEOUT_MS, MCP_TOOL_REQUEST_TIMEOUT_MS_DEFAULT, SESSION_CLEANUP_INTERVAL_MS, SESSION_TOOL_RESULT_CACHE_TIMEOUT_MS, STATUS_UPDATE_DEFAULT_INTERVAL_SECONDS, STATUS_UPDATE_DEFAULT_NUM_EVENTS, STREAM_BUFFER_MAX_SIZE_BYTES, STREAM_MAX_LIFETIME_MS, STREAM_PARSER_MAX_COLLECTED_PARTS, STREAM_PARSER_MAX_SNAPSHOT_SIZE, STREAM_PARSER_MAX_STREAMED_SIZE, STREAM_TEXT_GAP_THRESHOLD_MS, executionLimitsDefaults };

package/dist/create-app.d.ts

@@ -1,9 +1,9 @@
 import { SandboxConfig } from "./types/execution-context.js";
 import { CredentialStoreRegistry, ServerConfig } from "@inkeep/agents-core";
 import { Hono } from "hono";
-import * as hono_types0 from "hono/types";
+import * as hono_types3 from "hono/types";
 
 //#region src/create-app.d.ts
-declare function createExecutionHono(serverConfig: ServerConfig, credentialStores: CredentialStoreRegistry, sandboxConfig?: SandboxConfig): Hono<hono_types0.BlankEnv, hono_types0.BlankSchema, "/">;
+declare function createExecutionHono(serverConfig: ServerConfig, credentialStores: CredentialStoreRegistry, sandboxConfig?: SandboxConfig): Hono<hono_types3.BlankEnv, hono_types3.BlankSchema, "/">;
 //#endregion
 export { createExecutionHono };

package/dist/data/conversations.d.ts

@@ -1,7 +1,7 @@
 import { AgentConversationHistoryConfig, Artifact, ConversationHistoryConfig, ConversationScopeOptions } from "@inkeep/agents-core";
 
 //#region src/data/conversations.d.ts
-
+declare const compressionLocks: Map<string, Promise<any>>;
 /**
  * Creates default conversation history configuration
  * @param mode - The conversation history mode ('full' | 'scoped' | 'none')
@@ -64,7 +64,33 @@ declare function getFormattedConversationHistory({
   conversationId,
   currentMessage,
   options,
-  filters
+  filters,
+  sessionId,
+  summarizerModel
+}: {
+  tenantId: string;
+  projectId: string;
+  conversationId: string;
+  currentMessage?: string;
+  options?: ConversationHistoryConfig;
+  filters?: ConversationScopeOptions;
+  sessionId?: string;
+  summarizerModel?: any;
+}): Promise<string>;
+/**
+ * Modern conversation history retrieval with compression support
+ * Replaces getFormattedConversationHistory with built-in compression when needed
+ */
+declare function getConversationHistoryWithCompression({
+  tenantId,
+  projectId,
+  conversationId,
+  currentMessage,
+  options,
+  filters,
+  summarizerModel,
+  streamRequestId,
+  fullContextSize
 }: {
   tenantId: string;
   projectId: string;
@@ -72,7 +98,21 @@ declare function getFormattedConversationHistory({
   currentMessage?: string;
   options?: ConversationHistoryConfig;
   filters?: ConversationScopeOptions;
+  summarizerModel?: any;
+  streamRequestId?: string;
+  fullContextSize?: number;
 }): Promise<string>;
+/**
+ * Apply conversation compression using the BaseCompressor infrastructure
+ */
+declare function compressConversationIfNeeded(messages: any[], params: {
+  conversationId: string;
+  tenantId: string;
+  projectId: string;
+  summarizerModel: any;
+  streamRequestId?: string;
+  fullContextSize?: number;
+}): Promise<any[]>;
 /**
  * Get artifacts that are within the scope of the conversation history
  * Only returns artifacts from messages that are actually visible to the LLM
@@ -85,4 +125,4 @@ declare function getConversationScopedArtifacts(params: {
   historyConfig: AgentConversationHistoryConfig;
 }): Promise<Artifact[]>;
 //#endregion
-export { createDefaultConversationHistoryConfig, getConversationScopedArtifacts, getFormattedConversationHistory, getFullConversationContext, getScopedHistory, getUserFacingHistory, saveA2AMessageResponse };
+export { compressConversationIfNeeded, compressionLocks, createDefaultConversationHistoryConfig, getConversationHistoryWithCompression, getConversationScopedArtifacts, getFormattedConversationHistory, getFullConversationContext, getScopedHistory, getUserFacingHistory, saveA2AMessageResponse };

package/dist/data/conversations.js

@@ -1,8 +1,13 @@
+import { getLogger } from "../logger.js";
 import dbClient_default from "./db/dbClient.js";
-import { CONVERSATION_HISTORY_DEFAULT_LIMIT as CONVERSATION_HISTORY_DEFAULT_LIMIT$1 } from "../constants/execution-limits/index.js";
+import { CONVERSATION_ARTIFACTS_LIMIT, CONVERSATION_HISTORY_DEFAULT_LIMIT as CONVERSATION_HISTORY_DEFAULT_LIMIT$1 } from "../constants/execution-limits/index.js";
+import { getCompressionConfigForModel } from "../utils/model-context-utils.js";
+import { ConversationCompressor } from "../services/ConversationCompressor.js";
 import { CONVERSATION_HISTORY_MAX_OUTPUT_TOKENS_DEFAULT, createMessage, generateId, getConversationHistory } from "@inkeep/agents-core";
 
 //#region src/data/conversations.ts
+const logger = getLogger("conversations");
+const compressionLocks = /* @__PURE__ */ new Map();
 /**
 * Creates default conversation history configuration
 * @param mode - The conversation history mode ('full' | 'scoped' | 'none')
@@ -64,14 +69,39 @@ async function saveA2AMessageResponse(response, params) {
 */
 async function getScopedHistory({ tenantId, projectId, conversationId, filters, options }) {
 	try {
-		const messages = await getConversationHistory(dbClient_default)({
+		const allMessages = await getConversationHistory(dbClient_default)({
 			scopes: {
 				tenantId,
 				projectId
 			},
 			conversationId,
-			options
+			options: {
+				...options,
+				limit: 1e4,
+				includeInternal: true,
+				maxOutputTokens: void 0
+			}
 		});
+		const compressionSummaries = allMessages.filter((msg) => msg.messageType === "compression_summary" && msg.metadata?.compressionType === "conversation_history");
+		const latestCompressionSummary = compressionSummaries.length > 0 ? compressionSummaries.reduce((latest, current) => new Date(current.createdAt) > new Date(latest.createdAt) ? current : latest) : null;
+		let messages;
+		if (latestCompressionSummary) {
+			const summaryDate = new Date(latestCompressionSummary.createdAt);
+			messages = [latestCompressionSummary, ...allMessages.filter((msg) => new Date(msg.createdAt) > summaryDate && msg.messageType !== "compression_summary")];
+			logger.debug({
+				conversationId,
+				latestCompressionSummaryId: latestCompressionSummary.id,
+				summaryDate: summaryDate.toISOString(),
+				messagesAfterCompression: messages.length - 1,
+				totalMessages: allMessages.length
+			}, "Retrieved conversation with compression summary");
+		} else {
+			messages = allMessages;
+			logger.debug({
+				conversationId,
+				totalMessages: messages.length
+			}, "Retrieved conversation without compression summary");
+		}
 		if (!filters || !filters.subAgentId && !filters.taskId && !filters.delegationId && filters.isDelegated === void 0) return messages;
 		return messages.filter((msg) => {
 			if (msg.role === "user") return true;
@@ -139,7 +169,7 @@ async function getFullConversationContext(tenantId, projectId, conversationId, m
 /**
 * Get formatted conversation history for a2a
 */
-async function getFormattedConversationHistory({ tenantId, projectId, conversationId, currentMessage, options, filters }) {
+async function getFormattedConversationHistory({ tenantId, projectId, conversationId, currentMessage, options, filters, sessionId, summarizerModel }) {
 	const conversationHistory = await getScopedHistory({
 		tenantId,
 		projectId,
@@ -152,12 +182,284 @@ async function getFormattedConversationHistory({ tenantId, projectId, conversati
 		if (conversationHistory[conversationHistory.length - 1].content.text === currentMessage) messagesToFormat = conversationHistory.slice(0, -1);
 	}
 	if (!messagesToFormat.length) return "";
-	return `<conversation_history>\n${messagesToFormat.map((msg) => {
+	let finalMessagesToFormat = messagesToFormat;
+	if (sessionId && summarizerModel) finalMessagesToFormat = await compressConversationIfNeeded(messagesToFormat, {
+		conversationId,
+		tenantId,
+		projectId,
+		summarizerModel,
+		streamRequestId: sessionId
+	});
+	return `<conversation_history>\n${finalMessagesToFormat.map((msg) => {
+		let roleLabel;
+		if (msg.role === "user") roleLabel = "user";
+		else if (msg.role === "agent" && (msg.messageType === "a2a-request" || msg.messageType === "a2a-response")) roleLabel = `${msg.fromSubAgentId || msg.fromExternalAgentId || "unknown"} to ${msg.toSubAgentId || msg.toExternalAgentId || "unknown"}`;
+		else if (msg.role === "agent" && msg.messageType === "chat") roleLabel = `${msg.fromSubAgentId || "unknown"} to User`;
+		else if (msg.role === "assistant" && msg.messageType === "tool-result") roleLabel = `${msg.fromSubAgentId || "unknown"} tool: ${msg.metadata?.a2a_metadata?.toolName || "unknown"}`;
+		else roleLabel = msg.role || "system";
+		return `${roleLabel}: """${msg.content.text}"""`;
+	}).join("\n")}\n</conversation_history>\n`;
+}
+/**
+* Modern conversation history retrieval with compression support
+* Replaces getFormattedConversationHistory with built-in compression when needed
+*/
+async function getConversationHistoryWithCompression({ tenantId, projectId, conversationId, currentMessage, options, filters, summarizerModel, streamRequestId, fullContextSize }) {
+	const conversationHistory = await getScopedHistory({
+		tenantId,
+		projectId,
+		conversationId,
+		filters,
+		options: {
+			...options ?? createDefaultConversationHistoryConfig(),
+			includeInternal: true,
+			maxOutputTokens: void 0
+		}
+	});
+	let messagesToFormat = conversationHistory;
+	if (currentMessage && conversationHistory.length > 0) {
+		if (conversationHistory[conversationHistory.length - 1].content.text === currentMessage) messagesToFormat = conversationHistory.slice(0, -1);
+	}
+	if (!messagesToFormat.length) return "";
+	if (summarizerModel) {
+		const compressionInfo = getCompressionConfigForModel(summarizerModel, .5);
+		const estimatedTokens = messagesToFormat.reduce((total, msg) => {
+			const text = typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content);
+			return total + Math.ceil(text.length / 4);
+		}, 0);
+		const remaining = compressionInfo.hardLimit - estimatedTokens;
+		const compressionNeeded = remaining <= compressionInfo.safetyBuffer;
+		const contextWindowUtilization = compressionInfo.modelContextInfo.contextWindow ? (estimatedTokens / compressionInfo.modelContextInfo.contextWindow * 100).toFixed(1) : "unknown";
+		logger.info({
+			conversationId,
+			model: summarizerModel.model,
+			modelContextWindow: compressionInfo.modelContextInfo.contextWindow,
+			currentTokens: estimatedTokens,
+			hardLimit: compressionInfo.hardLimit,
+			safetyBuffer: compressionInfo.safetyBuffer,
+			remaining,
+			compressionNeeded,
+			contextWindowUtilization: `${contextWindowUtilization}%`,
+			messageCount: messagesToFormat.length,
+			source: compressionInfo.source
+		}, "Conversation history fetch - model context analysis");
+		const compressionSummary = messagesToFormat.find((msg) => msg.messageType === "compression_summary" && msg.metadata?.compressionType === "conversation_history");
+		if (compressionSummary) {
+			const messagesAfterCompression = messagesToFormat.filter((msg) => new Date(msg.createdAt) > new Date(compressionSummary.createdAt) && msg.messageType !== "compression_summary");
+			if (messagesAfterCompression.length >= 10) {
+				logger.info({
+					conversationId,
+					messagesAfterLastCompression: messagesAfterCompression.length,
+					lastCompressionDate: compressionSummary.createdAt
+				}, "Checking if re-compression needed for new messages");
+				const newMessagesCompressed = await compressConversationIfNeeded(messagesAfterCompression, {
+					conversationId,
+					tenantId,
+					projectId,
+					summarizerModel,
+					streamRequestId,
+					fullContextSize
+				});
+				if (newMessagesCompressed.length === 1 && newMessagesCompressed[0].messageType === "compression_summary") {
+					messagesToFormat = [compressionSummary, ...newMessagesCompressed];
+					logger.info({
+						conversationId,
+						totalCompressedMessages: messagesToFormat.length
+					}, "Re-compression completed - combined with existing summary");
+				} else messagesToFormat = [compressionSummary, ...messagesAfterCompression];
+			}
+		} else {
+			messagesToFormat.length;
+			messagesToFormat = await compressConversationIfNeeded(messagesToFormat, {
+				conversationId,
+				tenantId,
+				projectId,
+				summarizerModel,
+				streamRequestId,
+				fullContextSize
+			});
+		}
+		const compressedTokens = messagesToFormat.reduce((total, msg) => {
+			const text = typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content);
+			return total + Math.ceil(text.length / 4);
+		}, 0);
+		const compressionSummaryMessages = messagesToFormat.filter((msg) => msg.messageType === "compression_summary");
+		if (compressionSummaryMessages.length > 0) logger.info({
+			conversationId,
+			finalMessages: messagesToFormat.length,
+			compressionSummaries: compressionSummaryMessages.length,
+			finalTokens: compressedTokens,
+			contextWindowUtilization: compressionInfo.modelContextInfo.contextWindow ? `${(compressedTokens / compressionInfo.modelContextInfo.contextWindow * 100).toFixed(1)}%` : "unknown"
+		}, "Final conversation history with compression summaries");
+	}
+	return formatMessagesAsConversationHistory(messagesToFormat);
+}
+/**
+* Apply conversation compression using the BaseCompressor infrastructure
+*/
+async function compressConversationIfNeeded(messages, params) {
+	const { conversationId, tenantId, projectId, summarizerModel, streamRequestId } = params;
+	const lockKey = `${conversationId}_${tenantId}_${projectId}`;
+	if (compressionLocks.has(lockKey)) {
+		logger.debug({ conversationId }, "Waiting for existing compression to complete");
+		await compressionLocks.get(lockKey);
+		return messages;
+	}
+	const compressionPromise = performActualCompression(messages, params);
+	compressionLocks.set(lockKey, compressionPromise);
+	try {
+		return await compressionPromise;
+	} finally {
+		compressionLocks.delete(lockKey);
+	}
+}
+async function performActualCompression(messages, params) {
+	const { conversationId, tenantId, projectId, summarizerModel, streamRequestId } = params;
+	const compressor = new ConversationCompressor(streamRequestId || conversationId, conversationId, tenantId, projectId, void 0, summarizerModel);
+	if (!compressor.isCompressionNeeded(messages)) return messages;
+	logger.info({
+		conversationId,
+		messageCount: messages.length
+	}, "Applying conversation-level compression");
+	try {
+		const compressionResult = await compressor.safeCompress(messages, params.fullContextSize);
+		if (compressionResult.summary) {
+			const compressionMessage = await createMessage(dbClient_default)({
+				id: generateId(),
+				tenantId,
+				projectId,
+				conversationId,
+				role: "system",
+				content: { text: buildCompressionSummaryMessage(compressionResult.summary, compressionResult.artifactIds) },
+				visibility: "internal",
+				messageType: "compression_summary",
+				metadata: { a2a_metadata: {
+					compressionType: "conversation_history",
+					artifactIds: compressionResult.artifactIds,
+					originalMessageCount: messages.length,
+					compressedAt: (/* @__PURE__ */ new Date()).toISOString(),
+					summaryData: compressionResult.summary
+				} }
+			});
+			logger.debug({
+				conversationId,
+				originalMessageCount: messages.length,
+				artifactCount: compressionResult.artifactIds?.length || 0,
+				compressionMessageId: compressionMessage.id
+			}, "Conversation compression saved to messages table");
+			compressor.fullCleanup();
+			return [compressionMessage];
+		}
+		compressor.fullCleanup();
+		return messages;
+	} catch (error) {
+		logger.error({
+			conversationId,
+			error: error instanceof Error ? error.message : String(error)
+		}, "Conversation compression failed, using original messages");
+		compressor.fullCleanup();
+		return messages;
+	}
+}
+/**
+* Build a summary message for compressed conversation content
+*/
+function buildCompressionSummaryMessage(summary, artifactIds) {
+	const parts = [];
+	parts.push("=== CONVERSATION SUMMARY ===");
+	parts.push("Previous conversation has been compressed to save context space.");
+	parts.push("");
+	if (summary.conversation_overview) parts.push(`📋 Overview: ${summary.conversation_overview}`);
+	if (summary.user_goals?.primary) {
+		parts.push(`🎯 Primary Goal: ${summary.user_goals.primary}`);
+		if (summary.user_goals.secondary && summary.user_goals.secondary.length > 0) {
+			parts.push(`🎯 Secondary Goals:`);
+			summary.user_goals.secondary.forEach((goal) => parts.push(`  • ${goal}`));
+		}
+	}
+	if (summary.key_outcomes) {
+		if (summary.key_outcomes.completed && summary.key_outcomes.completed.length > 0) {
+			parts.push(`✅ Completed:`);
+			summary.key_outcomes.completed.forEach((item) => parts.push(`  • ${item}`));
+		}
+		if (summary.key_outcomes.discoveries && summary.key_outcomes.discoveries.length > 0) {
+			parts.push(`💡 Key Discoveries:`);
+			summary.key_outcomes.discoveries.forEach((discovery) => parts.push(`  • ${discovery}`));
+		}
+		if (summary.key_outcomes.partial && summary.key_outcomes.partial.length > 0) {
+			parts.push(`⏳ In Progress:`);
+			summary.key_outcomes.partial.forEach((item) => parts.push(`  • ${item}`));
+		}
+	}
+	if (summary.context_for_continuation) {
+		if (summary.context_for_continuation.current_state) parts.push(`📍 Current State: ${summary.context_for_continuation.current_state}`);
+		if (summary.context_for_continuation.next_logical_steps && summary.context_for_continuation.next_logical_steps.length > 0) {
+			parts.push(`📝 Next Steps:`);
+			summary.context_for_continuation.next_logical_steps.forEach((step) => parts.push(`  • ${step}`));
+		}
+		if (summary.context_for_continuation.important_context && summary.context_for_continuation.important_context.length > 0) {
+			parts.push(`🔑 Key Context:`);
+			summary.context_for_continuation.important_context.forEach((context) => parts.push(`  • ${context}`));
+		}
+	}
+	if (summary.technical_context) {
+		if (summary.technical_context.technologies && summary.technical_context.technologies.length > 0) parts.push(`🔧 Technologies: ${summary.technical_context.technologies.join(", ")}`);
+		if (summary.technical_context.issues_encountered && summary.technical_context.issues_encountered.length > 0) {
+			parts.push(`⚠️ Issues Encountered:`);
+			summary.technical_context.issues_encountered.forEach((issue) => parts.push(`  • ${issue}`));
+		}
+		if (summary.technical_context.solutions_applied && summary.technical_context.solutions_applied.length > 0) {
+			parts.push(`✨ Solutions Applied:`);
+			summary.technical_context.solutions_applied.forEach((solution) => parts.push(`  • ${solution}`));
+		}
+	}
+	if (summary.high_level) parts.push(`📋 Overview: ${summary.high_level}`);
+	if (summary.user_intent) parts.push(`🎯 User Goal: ${summary.user_intent}`);
+	if (summary.decisions && summary.decisions.length > 0) {
+		parts.push(`✅ Key Decisions Made:`);
+		summary.decisions.forEach((decision) => parts.push(`  • ${decision}`));
+	}
+	if (summary.next_steps && summary.next_steps.length > 0) {
+		parts.push(`📝 Planned Next Steps:`);
+		summary.next_steps.forEach((step) => parts.push(`  • ${step}`));
+	}
+	if (summary.open_questions && summary.open_questions.length > 0) {
+		parts.push(`❓ Outstanding Questions:`);
+		summary.open_questions.forEach((question) => parts.push(`  • ${question}`));
+	}
+	if (summary.conversation_artifacts && summary.conversation_artifacts.length > 0) {
+		parts.push(`💾 Research Artifacts: ${summary.conversation_artifacts.length} created from previous work`);
+		summary.conversation_artifacts.forEach((artifact) => {
+			parts.push(`   [ARTIFACT: ${artifact.id}]`);
+			parts.push(`   📋 ${artifact.name || "Research Data"}`);
+			if (artifact.content_summary) parts.push(`   📝 ${artifact.content_summary}`);
+			if (artifact.tool_name && artifact.tool_name !== "unknown") parts.push(`   🔧 Source: ${artifact.tool_name}`);
+			parts.push(`   🔗 Reference: <artifact:ref id="${artifact.id}" tool_call_id="${artifact.tool_call_id}" />`);
+			parts.push("");
+		});
+	} else if (artifactIds && artifactIds.length > 0) {
+		parts.push(`💾 Research Artifacts: ${artifactIds.length} created from previous work`);
+		artifactIds.forEach((artifactId) => {
+			parts.push(`   [ARTIFACT: ${artifactId}]`);
+			parts.push(`   🔗 Reference: <artifact:ref id="${artifactId}" />`);
+		});
+	}
+	parts.push("");
+	parts.push("=== END SUMMARY ===");
+	parts.push("Recent conversation continues below...");
+	return parts.join("\n");
+}
+/**
+* Format messages into conversation history string (extracted from legacy method)
+*/
+function formatMessagesAsConversationHistory(messages) {
+	return `<conversation_history>\n${messages.map((msg) => {
 		let roleLabel;
 		if (msg.role === "user") roleLabel = "user";
 		else if (msg.role === "agent" && (msg.messageType === "a2a-request" || msg.messageType === "a2a-response")) roleLabel = `${msg.fromSubAgentId || msg.fromExternalAgentId || "unknown"} to ${msg.toSubAgentId || msg.toExternalAgentId || "unknown"}`;
 		else if (msg.role === "agent" && msg.messageType === "chat") roleLabel = `${msg.fromSubAgentId || "unknown"} to User`;
 		else if (msg.role === "assistant" && msg.messageType === "tool-result") roleLabel = `${msg.fromSubAgentId || "unknown"} tool: ${msg.metadata?.a2a_metadata?.toolName || "unknown"}`;
+		else if (msg.role === "system") roleLabel = "system";
 		else roleLabel = msg.role || "system";
 		return `${roleLabel}: """${msg.content.text}"""`;
 	}).join("\n")}\n</conversation_history>\n`;
@@ -194,14 +496,19 @@ async function getConversationScopedArtifacts(params) {
 			});
 			referenceArtifacts.push(...artifacts);
 		}
-		(await import("../logger.js")).getLogger("conversations").debug({
+		const logger$1 = (await import("../logger.js")).getLogger("conversations");
+		const ARTIFACT_COUNT_LIMIT = CONVERSATION_ARTIFACTS_LIMIT;
+		const limitedArtifacts = referenceArtifacts.sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime()).slice(0, ARTIFACT_COUNT_LIMIT);
+		logger$1.debug({
 			conversationId,
 			visibleMessages: visibleMessages.length,
 			visibleTasks: visibleTaskIds.length,
-			artifacts: referenceArtifacts.length,
+			totalArtifacts: referenceArtifacts.length,
+			limitedArtifacts: limitedArtifacts.length,
+			artifactLimit: ARTIFACT_COUNT_LIMIT,
 			historyMode: historyConfig.mode
-		}, "Loaded conversation-scoped artifacts");
-		return referenceArtifacts;
+		}, "Loaded conversation-scoped artifacts with count limit");
+		return limitedArtifacts;
 	} catch (error) {
 		(await import("../logger.js")).getLogger("conversations").error({
 			error: error instanceof Error ? error.message : "Unknown error",
@@ -212,4 +519,4 @@ async function getConversationScopedArtifacts(params) {
 }
 
 //#endregion
-export { createDefaultConversationHistoryConfig, getConversationScopedArtifacts, getFormattedConversationHistory, getFullConversationContext, getScopedHistory, getUserFacingHistory, saveA2AMessageResponse };
+export { compressConversationIfNeeded, compressionLocks, createDefaultConversationHistoryConfig, getConversationHistoryWithCompression, getConversationScopedArtifacts, getFormattedConversationHistory, getFullConversationContext, getScopedHistory, getUserFacingHistory, saveA2AMessageResponse };

package/dist/handlers/executionHandler.js

@@ -2,8 +2,8 @@ import { getLogger } from "../logger.js";
 import { flushBatchProcessor } from "../instrumentation.js";
 import dbClient_default from "../data/db/dbClient.js";
 import { AGENT_EXECUTION_MAX_CONSECUTIVE_ERRORS } from "../constants/execution-limits/index.js";
-import { registerStreamHelper, unregisterStreamHelper } from "../utils/stream-registry.js";
 import { tracer } from "../utils/tracer.js";
+import { registerStreamHelper, unregisterStreamHelper } from "../utils/stream-registry.js";
 import { agentSessionManager } from "../services/AgentSession.js";
 import { resolveModelConfig } from "../utils/model-resolver.js";
 import { agentInitializingOp, completionOp, errorOp } from "../utils/agent-operations.js";

package/dist/index.d.ts

@@ -3,14 +3,14 @@ import { createExecutionHono } from "./create-app.js";
 import "./env.js";
 import { CredentialStore, ServerConfig } from "@inkeep/agents-core";
 import { Hono } from "hono";
-import * as hono_types1 from "hono/types";
+import * as hono_types0 from "hono/types";
 
 //#region src/index.d.ts
-declare const app: Hono<hono_types1.BlankEnv, hono_types1.BlankSchema, "/">;
+declare const app: Hono<hono_types0.BlankEnv, hono_types0.BlankSchema, "/">;
 declare function createExecutionApp(config?: {
   serverConfig?: ServerConfig;
   credentialStores?: CredentialStore[];
   sandboxConfig?: SandboxConfig;
-}): Hono<hono_types1.BlankEnv, hono_types1.BlankSchema, "/">;
+}): Hono<hono_types0.BlankEnv, hono_types0.BlankSchema, "/">;
 //#endregion
 export { Hono, type NativeSandboxConfig, type SandboxConfig, type VercelSandboxConfig, createExecutionApp, createExecutionHono, app as default };

package/dist/services/AgentSession.d.ts

@@ -128,7 +128,7 @@ interface CompressionEventData {
   artifactCount: number;
   contextSizeBefore: number;
   contextSizeAfter: number;
-  compressionType: 'mid_generation' | 'full_conversation';
+  compressionType: 'mid_generation' | 'conversation_level';
 }
 interface ErrorEventData {
   message: string;

package/dist/services/AgentSession.js

@@ -2,10 +2,10 @@ import { getLogger } from "../logger.js";
 import dbClient_default from "../data/db/dbClient.js";
 import { ARTIFACT_GENERATION_BACKOFF_INITIAL_MS, ARTIFACT_GENERATION_BACKOFF_MAX_MS, ARTIFACT_GENERATION_MAX_RETRIES, ARTIFACT_SESSION_MAX_PENDING, ARTIFACT_SESSION_MAX_PREVIOUS_SUMMARIES, STATUS_UPDATE_DEFAULT_INTERVAL_SECONDS, STATUS_UPDATE_DEFAULT_NUM_EVENTS } from "../constants/execution-limits/index.js";
 import { toolSessionManager } from "../agents/ToolSessionManager.js";
+import { setSpanWithError as setSpanWithError$1, tracer } from "../utils/tracer.js";
 import { getFormattedConversationHistory } from "../data/conversations.js";
 import { defaultStatusSchemas } from "../utils/default-status-schemas.js";
 import { getStreamHelper } from "../utils/stream-registry.js";
-import { setSpanWithError as setSpanWithError$1, tracer } from "../utils/tracer.js";
 import { ArtifactService } from "./ArtifactService.js";
 import { ArtifactParser } from "./ArtifactParser.js";
 import { z } from "@hono/zod-openapi";