comet-ml
diff --git a/‎apps/opik-backend/config.yml‎
Lines changed: 14 additions & 0 deletions b/‎apps/opik-backend/config.yml‎
Lines changed: 14 additions & 0 deletions
diff --git a/‎apps/opik-backend/src/main/java/com/comet/opik/api/resources/v1/events/AgenticScoringService.java‎
Lines changed: 474 additions & 0 deletions b/‎apps/opik-backend/src/main/java/com/comet/opik/api/resources/v1/events/AgenticScoringService.java‎
Lines changed: 474 additions & 0 deletions
diff --git a/‎apps/opik-backend/src/main/java/com/comet/opik/api/resources/v1/events/OnlineScoringBaseScorer.java‎
Lines changed: 10 additions & 33 deletions b/‎apps/opik-backend/src/main/java/com/comet/opik/api/resources/v1/events/OnlineScoringBaseScorer.java‎
Lines changed: 10 additions & 33 deletions
@@ -671,6 +671,20 @@ onlineScoring:
   #   tool. The URL is consumed within a single tool-call round; 120 s is ample for most providers.
   #   Capped at 3600 s — longer-lived URLs are a security risk if the URL leaks.
   agenticToolsS3PresignTtlSeconds: ${ONLINE_SCORING_AGENTIC_TOOLS_S3_PRESIGN_TTL_SECONDS:-120}
+  # Default: 4000
+  # Description: Per-variable substitution cap (in characters) for the {{trace}}/{{span}} structure-injection
+  #   and agentic-tools paths. Large enough that small entity input/output renders inline, small enough that a
+  #   huge entity doesn't blow context (the agent fetches the rest via the read tool). 500-100000.
+  maxPromptFieldChars: ${ONLINE_SCORING_MAX_PROMPT_FIELD_CHARS:-4000}
+  # Default: 5
+  # Description: Attachment-upload race tolerance for the {{trace}}/{{span}} structures — how many times the
+  #   attachment lookup is retried when the entity references an attachment that isn't persisted yet. Interim
+  #   guard (0-20; 0 disables retrying) pending the pre-evaluation dispatch delay (OPIK-7224).
+  attachmentFetchMaxRetries: ${ONLINE_SCORING_ATTACHMENT_FETCH_MAX_RETRIES:-5}
+  # Default: 300ms
+  # Description: Delay between attachment-lookup retries (see attachmentFetchMaxRetries). Worst-case added
+  #   latency ≈ attachmentFetchMaxRetries × this, and only for entities that expect an attachment. 50ms-5s.
+  attachmentFetchRetryDelay: ${ONLINE_SCORING_ATTACHMENT_FETCH_RETRY_DELAY:-300ms}
   ## scorer: options from AutomationRuleEvaluatorType
   ## streamName: the name of the stream in redis
   ## codec: 'json' when there are non-java consumers, 'java' for java consumers only
 
@@ -7,7 +7,6 @@
 import com.comet.opik.api.filter.Operator;
 import com.comet.opik.api.filter.TraceField;
 import com.comet.opik.api.filter.TraceFilter;
-import com.comet.opik.api.resources.v1.events.tools.TraceToolContext;
 import com.comet.opik.domain.FeedbackScoreService;
 import com.comet.opik.domain.TraceSearchCriteria;
 import com.comet.opik.domain.TraceService;
@@ -27,14 +26,12 @@
 import java.math.BigDecimal;
 import java.util.List;
 import java.util.Map;
-import java.util.Optional;
 import java.util.UUID;
 import java.util.concurrent.atomic.AtomicReference;
 import java.util.stream.Collectors;
 
 import static com.comet.opik.api.FeedbackScoreItem.FeedbackScoreBatchItem;
 import static com.comet.opik.api.FeedbackScoreItem.FeedbackScoreBatchItemThread;
-import static com.comet.opik.infrastructure.log.LogContextAware.wrapWithMdc;
 
 /**
  * Base online scorer for all particular implementations to extend. It listens to a Redis stream for
@@ -46,13 +43,22 @@
 public abstract class OnlineScoringBaseScorer<M extends RedisSubscriberMessage> extends BaseRedisSubscriber<M> {
 
     public static final int TRACE_PAGE_LIMIT = 2000;
+
+    /**
+     * Truncation marker hint for the no-tools inline {@code {{trace}}} / {@code {{span}}} fallback. There
+     * are no {@code read}/{@code jq} tools to drill in, so the hint just flags that the value was
+     * truncated rather than pointing at a (non-existent) follow-up tool.
+     */
+    protected static final String INLINE_TRUNCATION_HINT = "full content not shown";
+
     private static final String ONLINE_SCORING_NAMESPACE = "online_scoring";
 
     /**
      * Logger for the actual subclass, in order to have the correct class name in the logs.
      */
     private final Logger log = LoggerFactory.getLogger(this.getClass());
 
+    protected final OnlineScoringConfig onlineScoringConfig;
     protected final FeedbackScoreService feedbackScoreService;
     protected final TraceService traceService;
     protected final AutomationRuleEvaluatorType type;
@@ -68,41 +74,12 @@ protected OnlineScoringBaseScorer(@NonNull @Config OnlineScoringConfig config,
                 OnlineScoringConfig.PAYLOAD_FIELD,
                 ONLINE_SCORING_NAMESPACE,
                 metricsBaseName);
+        this.onlineScoringConfig = config;
         this.feedbackScoreService = feedbackScoreService;
         this.traceService = traceService;
         this.type = type;
     }
 
-    /**
-     * Shared error surfacing for the agentic-tools path: when the tool-call loop fails after at
-     * least one attachment was injected as multimodal content, the most likely cause is the judge
-     * model rejecting that media type (we attempt all types rather than pre-gating). Emit a clear,
-     * attachment-attributed user-facing message before propagating, so a vision-incapable model
-     * produces an understandable error rather than a raw provider stack trace. With no injected
-     * media the failure passes through untouched.
-     *
-     * <p>Static + parameterized on {@code userFacingLogger} / {@code modelName} so the trace-, span-
-     * and thread-level scorers can all reuse it despite each owning its own logger and model accessor.
-     */
-    protected static <T> Mono<T> surfaceInjectedMediaFailure(@NonNull Throwable error,
-            @NonNull TraceToolContext ctx, String modelName, @NonNull Logger userFacingLogger,
-            @NonNull Map<String, String> mdc) {
-        if (ctx.hasInjectedMedia()) {
-            String attachments = ctx.getInjectedAttachments().stream()
-                    .map(a -> "'%s' (%s)".formatted(a.fileName(), a.category().name().toLowerCase()))
-                    .collect(Collectors.joining(", "));
-            String detail = Optional.ofNullable(error.getCause()).map(Throwable::getMessage)
-                    .orElse(error.getMessage());
-            try (var logContext = wrapWithMdc(mdc)) {
-                userFacingLogger.error(
-                        "Scoring failed after loading attachment(s) {}; the judge model '{}' may not support this"
-                                + " attachment type. Use a model that supports the attachment's media type. Details: {}",
-                        attachments, modelName, detail);
-            }
-        }
-        return Mono.error(error);
-    }
-
     /**
      * Propagates the workspace/user the message belongs to onto the reactive context for the whole
      * scoring chain (feedback-score persistence reads it). Per-message throughput and error metrics are