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

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 { generateObject } 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 { object: summary } = await generateObject({
+			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.`,
+			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.js

@@ -36,42 +36,29 @@ async function distillConversation(params) {
 	try {
 		const modelToUse = summarizerModel;
 		if (!modelToUse?.model?.trim()) throw new Error("Summarizer model is required");
-		const model = ModelFactory.createModel(modelToUse);
-		const existingSummaryContext = currentSummary ? `**Current summary:**\n\n\`\`\`json\n${JSON.stringify(currentSummary, null, 2)}\n\`\`\`` : "**Current summary:** None (first distillation)";
-		const formattedMessages = 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");
-		logger.debug({
-			conversationId,
-			messageCount: messages.length,
-			formattedLength: formattedMessages.length,
-			sampleMessages: messages.slice(0, 2).map((m) => ({
-				role: m.role,
-				contentType: typeof m.content,
-				hasContent: !!m.content
-			}))
-		}, "Formatting messages for distillation");
 		const { object: summary } = await generateObject({
-			model,
+			model: ModelFactory.createModel(modelToUse),
 			prompt: `You are a conversation summarization assistant. Your job is to create or update a compact, structured summary that captures VALUABLE CONTENT and FINDINGS, not just operational details.
 
-${existingSummaryContext}
+${currentSummary ? `**Current summary:**\n\n\`\`\`json\n${JSON.stringify(currentSummary, null, 2)}\n\`\`\`` : "**Current summary:** None (first distillation)"}
 
 **Messages to summarize:**
 
 \`\`\`text
-${formattedMessages}
+${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.output)}`);
+					}
+				} 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/update a summary using this exact JSON schema:
@@ -109,6 +96,7 @@ Create/update a summary using this exact JSON schema:
 🎯 **BE CONCRETE**: Use specific details from tool results, not generic descriptions
 🎯 **BE CONCISE**: Keep ALL fields brief - you are compressing to save context, not writing a report
 🎯 **LIMIT NEXT STEPS**: Agent has already done substantial work - suggest minimal follow-up actions only
+🎯 **HANDLE TRANSFERS SIMPLY**: Agent transfers/delegations are just routing - don't look for reasons or justifications. Simply note "conversation transferred to [specialist]" if relevant.
 
 **Examples:**
 ❌ BAD: "Assistant used search tool and created artifacts"
@@ -117,18 +105,15 @@ Create/update a summary using this exact JSON schema:
 ❌ BAD: "Tool calls were made to gather information"  
 ✅ GOOD: "Platform includes 10 feature categories: chat widgets, knowledge base, analytics, integrations, theming options"
 
+❌ BAD: "Assistant needed to transfer to QA because user required specialized testing help"
+✅ GOOD: "Conversation transferred to QA specialist"
+
 **Focus on WHAT WAS LEARNED, not HOW IT WAS LEARNED**
 
 Return **only** valid JSON.`,
 			schema: ConversationSummarySchema
 		});
 		summary.session_id = conversationId;
-		logger.info({
-			conversationId,
-			messageCount: messages.length,
-			artifactsCount: summary.related_artifacts?.length || 0,
-			decisionsCount: summary.decisions.length
-		}, "Successfully distilled conversation");
 		return summary;
 	} catch (error) {
 		logger.error({

package/dist/utils/model-context-utils.d.ts

@@ -11,6 +11,12 @@ interface ModelContextInfo {
   modelId: string;
   source: 'llm-info' | 'fallback';
 }
+/**
+ * Extract model ID from model string for llm-info lookup
+ * Includes smart mapping to find dated versions for models that don't have exact matches
+ */
+declare function extractModelIdForLlmInfo(modelInput: string): string;
+declare function extractModelIdForLlmInfo(modelSettings?: ModelSettings): string | null;
 /**
  * Get context window size for a model using llm-info
  * Falls back to default values if model not found
@@ -19,8 +25,10 @@ declare function getModelContextWindow(modelSettings?: ModelSettings): ModelCont
 /**
  * Get compression configuration based on model context window
  * Uses actual model context window when available, otherwise falls back to environment variables
+ * @param modelSettings - Model settings to get context window for
+ * @param targetPercentage - Target percentage of context window to use (e.g., 0.5 for conversation, undefined for model-aware defaults)
  */
-declare function getCompressionConfigForModel(modelSettings?: ModelSettings): {
+declare function getCompressionConfigForModel(modelSettings?: ModelSettings, targetPercentage?: number): {
   hardLimit: number;
   safetyBuffer: number;
   enabled: boolean;
@@ -28,4 +36,4 @@ declare function getCompressionConfigForModel(modelSettings?: ModelSettings): {
   modelContextInfo: ModelContextInfo;
 };
 //#endregion
-export { ModelContextInfo, getCompressionConfigForModel, getModelContextWindow };
+export { ModelContextInfo, extractModelIdForLlmInfo, getCompressionConfigForModel, getModelContextWindow };

package/dist/utils/model-context-utils.js

@@ -1,19 +1,27 @@
 import { getLogger } from "../logger.js";
+import { COMPRESSION_ENABLED, COMPRESSION_HARD_LIMIT, COMPRESSION_SAFETY_BUFFER } from "../constants/execution-limits/index.js";
 import { ModelInfoMap } from "llm-info";
 
 //#region src/utils/model-context-utils.ts
 const logger = getLogger("ModelContextUtils");
-/**
-* Extract model ID from model settings for llm-info lookup
-*/
-function extractModelIdForLlmInfo(modelSettings) {
-	if (!modelSettings?.model) return null;
-	const modelString = modelSettings.model.trim();
+function extractModelIdForLlmInfo(modelInput) {
+	let modelString;
+	if (typeof modelInput === "string") {
+		modelString = modelInput.trim();
+		if (!modelString) return null;
+	} else if (modelInput?.model) {
+		modelString = modelInput.model.trim();
+		if (!modelString) return null;
+	} else return null;
+	let modelId;
 	if (modelString.includes("/")) {
 		const parts = modelString.split("/");
-		return parts[parts.length - 1];
-	}
-	return modelString;
+		modelId = parts[parts.length - 1];
+	} else modelId = modelString;
+	if (modelId in ModelInfoMap) return modelId;
+	const matchingModels = Object.keys(ModelInfoMap).filter((key) => key.startsWith(modelId));
+	if (matchingModels.length > 0) return matchingModels.sort().reverse()[0];
+	return modelId;
 }
 /**
 * Get context window size for a model using llm-info
@@ -54,7 +62,8 @@ function getModelContextWindow(modelSettings) {
 				modelId,
 				source: "llm-info"
 			};
-		} else logger.debug({
+		}
+		logger.debug({
 			modelId,
 			modelDetails,
 			originalModel: modelSettings.model
@@ -86,11 +95,11 @@ function getCompressionParams(contextWindow) {
 		threshold: .85,
 		bufferPct: .1
 	};
-	else if (contextWindow < 5e5) return {
+	if (contextWindow < 5e5) return {
 		threshold: .9,
 		bufferPct: .07
 	};
-	else return {
+	return {
 		threshold: .95,
 		bufferPct: .04
 	};
@@ -98,28 +107,52 @@ function getCompressionParams(contextWindow) {
 /**
 * Get compression configuration based on model context window
 * Uses actual model context window when available, otherwise falls back to environment variables
+* @param modelSettings - Model settings to get context window for
+* @param targetPercentage - Target percentage of context window to use (e.g., 0.5 for conversation, undefined for model-aware defaults)
 */
-function getCompressionConfigForModel(modelSettings) {
+function getCompressionConfigForModel(modelSettings, targetPercentage) {
 	const modelContextInfo = getModelContextWindow(modelSettings);
-	const envHardLimit = parseInt(process.env.AGENTS_COMPRESSION_HARD_LIMIT || "120000");
-	const envSafetyBuffer = parseInt(process.env.AGENTS_COMPRESSION_SAFETY_BUFFER || "20000");
-	const enabled = process.env.AGENTS_COMPRESSION_ENABLED !== "false";
+	const envHardLimit = parseInt(process.env.AGENTS_COMPRESSION_HARD_LIMIT || COMPRESSION_HARD_LIMIT.toString());
+	const envSafetyBuffer = parseInt(process.env.AGENTS_COMPRESSION_SAFETY_BUFFER || COMPRESSION_SAFETY_BUFFER.toString());
+	const enabled = process.env.AGENTS_COMPRESSION_ENABLED !== "false" && COMPRESSION_ENABLED;
 	if (modelContextInfo.hasValidContextWindow && modelContextInfo.contextWindow) {
-		const params = getCompressionParams(modelContextInfo.contextWindow);
-		const hardLimit = Math.floor(modelContextInfo.contextWindow * params.threshold);
-		const safetyBuffer = Math.floor(modelContextInfo.contextWindow * params.bufferPct);
-		const triggerPoint = hardLimit - safetyBuffer;
-		const triggerPercentage = (triggerPoint / modelContextInfo.contextWindow * 100).toFixed(1);
-		logger.info({
-			modelId: modelContextInfo.modelId,
-			contextWindow: modelContextInfo.contextWindow,
-			hardLimit,
-			safetyBuffer,
-			triggerPoint,
-			triggerPercentage: `${triggerPercentage}%`,
-			threshold: params.threshold,
-			bufferPct: params.bufferPct
-		}, "Using model-size aware compression configuration");
+		let hardLimit;
+		let safetyBuffer;
+		let logContext;
+		if (targetPercentage !== void 0) {
+			hardLimit = Math.floor(modelContextInfo.contextWindow * targetPercentage);
+			safetyBuffer = Math.floor(modelContextInfo.contextWindow * .05);
+			const triggerPoint = hardLimit - safetyBuffer;
+			const triggerPercentage = (triggerPoint / modelContextInfo.contextWindow * 100).toFixed(1);
+			logContext = {
+				modelId: modelContextInfo.modelId,
+				contextWindow: modelContextInfo.contextWindow,
+				hardLimit,
+				safetyBuffer,
+				triggerPoint,
+				triggerPercentage: `${triggerPercentage}%`,
+				targetPercentage: `${(targetPercentage * 100).toFixed(1)}%`,
+				compressionType: targetPercentage <= .6 ? "conversation" : "mid-generation"
+			};
+			logger.info(logContext, "Using percentage-based compression configuration");
+		} else {
+			const params = getCompressionParams(modelContextInfo.contextWindow);
+			hardLimit = Math.floor(modelContextInfo.contextWindow * params.threshold);
+			safetyBuffer = Math.floor(modelContextInfo.contextWindow * params.bufferPct);
+			const triggerPoint = hardLimit - safetyBuffer;
+			const triggerPercentage = (triggerPoint / modelContextInfo.contextWindow * 100).toFixed(1);
+			logContext = {
+				modelId: modelContextInfo.modelId,
+				contextWindow: modelContextInfo.contextWindow,
+				hardLimit,
+				safetyBuffer,
+				triggerPoint,
+				triggerPercentage: `${triggerPercentage}%`,
+				threshold: params.threshold,
+				bufferPct: params.bufferPct
+			};
+			logger.info(logContext, "Using model-size aware compression configuration");
+		}
 		return {
 			hardLimit,
 			safetyBuffer,
@@ -127,23 +160,22 @@ function getCompressionConfigForModel(modelSettings) {
 			source: "model-specific",
 			modelContextInfo
 		};
-	} else {
-		const source = process.env.AGENTS_COMPRESSION_HARD_LIMIT ? "environment" : "default";
-		logger.debug({
-			modelId: modelContextInfo.modelId,
-			hardLimit: envHardLimit,
-			safetyBuffer: envSafetyBuffer,
-			source
-		}, "Using fallback compression configuration");
-		return {
-			hardLimit: envHardLimit,
-			safetyBuffer: envSafetyBuffer,
-			enabled,
-			source,
-			modelContextInfo
-		};
 	}
+	const source = process.env.AGENTS_COMPRESSION_HARD_LIMIT ? "environment" : "default";
+	logger.debug({
+		modelId: modelContextInfo.modelId,
+		hardLimit: envHardLimit,
+		safetyBuffer: envSafetyBuffer,
+		source
+	}, "Using fallback compression configuration");
+	return {
+		hardLimit: envHardLimit,
+		safetyBuffer: envSafetyBuffer,
+		enabled,
+		source,
+		modelContextInfo
+	};
 }
 
 //#endregion
-export { getCompressionConfigForModel, getModelContextWindow };
+export { extractModelIdForLlmInfo, getCompressionConfigForModel, getModelContextWindow };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inkeep/agents-run-api",
-  "version": "0.0.0-dev-20260105192809",
+  "version": "0.0.0-dev-20260105194521",
   "description": "Agents Run API for Inkeep Agent Framework - handles chat, agent execution, and streaming",
   "types": "dist/index.d.ts",
   "exports": {
@@ -41,7 +41,7 @@
     "hono": "^4.10.4",
     "jmespath": "^0.16.0",
     "llm-info": "^1.0.69",
-    "@inkeep/agents-core": "^0.0.0-dev-20260105192809"
+    "@inkeep/agents-core": "^0.0.0-dev-20260105194521"
   },
   "peerDependencies": {
     "@hono/zod-openapi": "^1.1.5",