Bugfix/compressor bug

agents-api/src/domains/run/agents/tools/default-tools.ts

@@ -3,6 +3,7 @@ import { type Tool, type ToolSet, tool } from 'ai';
 import { getLogger } from '../../../../logger';
 import { formatOversizedRetrievalReason } from '../../artifacts/artifact-utils';
 import { getModelAwareCompressionConfig } from '../../compression/BaseCompressor';
+import { SENTINEL_KEY } from '../../constants/artifact-syntax';
 import { agentSessionManager } from '../../session/AgentSession';
 import type { AgentRunContext } from '../agent-types';
 import { wrapToolWithStreaming } from './tool-wrapper';
@@ -20,6 +21,21 @@ export function getArtifactTools(ctx: AgentRunContext): Tool<any, any> {
     execute: async ({ artifactId, toolCallId }) => {
       logger.info({ artifactId, toolCallId }, 'get_artifact_full executed');
 
+      const compressor = ctx.currentCompressor;
+      if (compressor?.hasSummarizedArtifact(artifactId)) {
+        const summarized = compressor.getSummarizedArtifact(artifactId);
+        logger.info(
+          { artifactId, toolCallId },
+          'Blocked retrieval of artifact already summarized in compression'
+        );
+        return {
+          artifactId,
+          status: 'already_summarized',
+          key_findings: summarized?.key_findings ?? [],
+          hint: `This artifact's key findings are already in your compressed context. Use them directly to answer. To pass this artifact to a tool, use { "${SENTINEL_KEY.ARTIFACT}": "${artifactId}", "${SENTINEL_KEY.TOOL}": "${summarized?.tool_call_id ?? toolCallId}" } sentinel instead of retrieving it.`,
+        };
+      }
+
       const streamRequestId = ctx.streamRequestId ?? '';
       const artifactService = agentSessionManager.getArtifactService(streamRequestId);
 

agents-api/src/domains/run/compression/BaseCompressor.ts

@@ -1,6 +1,6 @@
 import { randomUUID } from 'node:crypto';
 import type { ModelSettings } from '@inkeep/agents-core';
-import { getLedgerArtifacts, SPAN_KEYS } from '@inkeep/agents-core';
+import { getLedgerArtifacts, SPAN_KEYS, upsertLedgerArtifact } from '@inkeep/agents-core';
 import { type Span, SpanStatusCode } from '@opentelemetry/api';
 import runDbClient from '../../../data/db/runDbClient';
 import { getLogger } from '../../../logger';
@@ -528,6 +528,16 @@ export abstract class BaseCompressor {
     );
 
     this.cumulativeSummary = summary;
+
+    if (summary.related_artifacts?.length) {
+      this.persistArtifactKeyFindings(summary.related_artifacts).catch((err) =>
+        logger.warn(
+          { err: err instanceof Error ? err.message : String(err) },
+          'Failed to persist key_findings to artifacts'
+        )
+      );
+    }
+
     return summary;
   }
 
@@ -604,6 +614,64 @@ export abstract class BaseCompressor {
     return this.cumulativeSummary;
   }
 
+  hasSummarizedArtifact(artifactId: string): boolean {
+    return this.cumulativeSummary?.related_artifacts?.some((a) => a.id === artifactId) ?? false;
+  }
+
+  getSummarizedArtifact(
+    artifactId: string
+  ): { key_findings: string[]; tool_call_id: string } | null {
+    const artifact = this.cumulativeSummary?.related_artifacts?.find((a) => a.id === artifactId);
+    if (!artifact) return null;
+    return {
+      key_findings: artifact.key_findings,
+      tool_call_id: artifact.tool_call_id,
+    };
+  }
+
+  protected async persistArtifactKeyFindings(
+    relatedArtifacts: NonNullable<ConversationSummary['related_artifacts']>
+  ): Promise<void> {
+    for (const artifact of relatedArtifacts) {
+      if (!artifact.id || !artifact.key_findings?.length) continue;
+      try {
+        const existing = await getLedgerArtifacts(runDbClient)({
+          scopes: { tenantId: this.tenantId, projectId: this.projectId },
+          artifactId: artifact.id,
+        });
+        if (existing.length === 0) continue;
+
+        const dbArtifact = existing[0];
+        const parts = (dbArtifact.parts ?? []) as any[];
+        if (parts.length > 0 && parts[0]?.data?.summary) {
+          parts[0].data.summary = {
+            ...parts[0].data.summary,
+            key_findings: artifact.key_findings,
+          };
+        }
+
+        await upsertLedgerArtifact(runDbClient)({
+          scopes: { tenantId: this.tenantId, projectId: this.projectId },
+          contextId: this.conversationId,
+          taskId: dbArtifact.taskId ?? `task_${this.conversationId}-${this.sessionId}`,
+          toolCallId: dbArtifact.toolCallId,
+          artifact: {
+            ...dbArtifact,
+            parts,
+          },
+        });
+      } catch (error) {
+        logger.warn(
+          {
+            artifactId: artifact.id,
+            error: error instanceof Error ? error.message : String(error),
+          },
+          'Failed to persist key_findings to artifact'
+        );
+      }
+    }
+  }
+
   cleanup(options: { resetSummary?: boolean; keepRecentToolCalls?: number } = {}): void {
     const { resetSummary = false, keepRecentToolCalls = 0 } = options;
     if (keepRecentToolCalls > 0) {