@cat-factory/app 0.232.2 → 0.233.0

package/app/utils/observability.ts

@@ -2,7 +2,17 @@
 // rollups + the drill-down panel). Kept here so the components stay declarative and
 // the number-crunching is unit-testable.
 
-import type { PipelineStep, StepMetrics, StepPhaseMetrics } from '~/types/execution'
+import { classifyLlmCallOutcome } from '@cat-factory/contracts'
+import type {
+  AgentFailure,
+  AgentToolCall,
+  LlmCallMetric,
+  LlmCallOutcome,
+  PipelineStep,
+  RunToolCallFailures,
+  StepMetrics,
+  StepPhaseMetrics,
+} from '~/types/execution'
 
 /** Compact token count: 1234 → "1.2k", 980 → "980", 2_500_000 → "2.5M". */
 export function formatTokens(n: number): string {
@@ -174,6 +184,227 @@ export function foldRunPhaseMetrics(steps: readonly PipelineStep[]): StepPhaseMe
   )
 }
 
+// --- failing-call-first triage ---------------------------------------------------------------
+// The panel's top section answers "what broke" before the operator reads anything. Everything it
+// shows is DERIVED here rather than in the component, for the usual reason plus one specific to
+// this surface: the difference between "nothing failed" and "we recorded nothing" is a judgement
+// with three inputs, and getting it wrong renders a confident all-clear over a run that died.
+
+/** Which calls a drill-down list is narrowed to. `all` is the default: no filter. */
+export type CallOutcomeFilter = 'all' | LlmCallOutcome
+/** Which tool calls a trajectory list is narrowed to (a tool has no `warning` class). */
+export type ToolOutcomeFilter = 'all' | 'ok' | 'error'
+
+/** How many calls fall in each outcome class, so a filter control can state what it hides. */
+export interface CallOutcomeCounts {
+  all: number
+  ok: number
+  warning: number
+  error: number
+}
+
+/**
+ * Count a run's calls by outcome, classified through the SHARED rule in `@cat-factory/contracts`
+ * (the same one the row badge and the backend's `?outcome=` predicate use), so a chip reading
+ * "2 errors" and a list showing three red rows is not a state this can reach.
+ */
+export function countCallOutcomes(calls: readonly LlmCallMetric[]): CallOutcomeCounts {
+  const counts: CallOutcomeCounts = { all: calls.length, ok: 0, warning: 0, error: 0 }
+  for (const call of calls) counts[classifyLlmCallOutcome(call)] += 1
+  return counts
+}
+
+/** Narrow a call list to one outcome class; `all` passes the list through untouched. */
+export function filterCallsByOutcome(
+  calls: readonly LlmCallMetric[],
+  filter: CallOutcomeFilter,
+): LlmCallMetric[] {
+  if (filter === 'all') return [...calls]
+  return calls.filter((call) => classifyLlmCallOutcome(call) === filter)
+}
+
+/** Narrow a tool-call trajectory to the failing (or the succeeding) calls. */
+export function filterToolCallsByOutcome(
+  toolCalls: readonly AgentToolCall[],
+  filter: ToolOutcomeFilter,
+): AgentToolCall[] {
+  if (filter === 'all') return [...toolCalls]
+  return toolCalls.filter((call) => call.ok === (filter === 'ok'))
+}
+
+/**
+ * What one telemetry sink was able to say about this run.
+ *
+ * A sink that has not answered and a sink that answered "nothing" are different facts, and the
+ * one thing this surface must never do is render them alike. A bare row count cannot hold the
+ * difference: zero rows is what a still-loading read, a failed read, an unwired sink and a
+ * genuinely quiet run all look like from the outside.
+ *
+ * - `pending`: no answer yet — in flight, or never requested. Not evidence, and never a clean
+ *   bill of health.
+ * - `unreachable`: the read FAILED. The strongest of the four, because it means no conclusion is
+ *   available at all — an HTTP error rendered as "no rows recorded" is a claim about the run
+ *   made out of a claim about the network.
+ * - `answered`: the sink spoke. `rows` may be 0, and THAT is the honest "nothing was recorded".
+ */
+export type SinkAnswer =
+  | { status: 'pending' }
+  | { status: 'unreachable' }
+  | { status: 'answered'; rows: number }
+
+/**
+ * Read one sink's answer off the store flags that describe it.
+ *
+ * The precedence is the point. An in-flight read is PENDING even when a previous answer or a
+ * previous error is still in hand, because what the panel says next depends on what is coming
+ * back, not on what it happened to be holding. Never-requested collapses into pending for the
+ * same reason: both are "nobody has answered", which is exactly what must not be rendered as
+ * "the answer was nothing".
+ */
+export function sinkAnswer(input: {
+  loading: boolean
+  error: string | null
+  loaded: boolean
+  rows: number
+}): SinkAnswer {
+  if (input.loading) return { status: 'pending' }
+  if (input.error) return { status: 'unreachable' }
+  return input.loaded ? { status: 'answered', rows: input.rows } : { status: 'pending' }
+}
+
+/** Whether a sink answered and holds at least one row for the run. */
+function answeredWithRows(answer: SinkAnswer): boolean {
+  return answer.status === 'answered' && answer.rows > 0
+}
+
+/**
+ * What the run's telemetry says about its failure, ready to render.
+ *
+ * `failure` is the run's own structured record (the `agent_runs.failure` JSON the engine writes);
+ * the two evidence rows are the calls that ACTUALLY failed, which is the part the operator
+ * otherwise finds by scrolling. They are independent: a run can fail with neither (the engine
+ * died, or the container never came up), with one, or with both.
+ */
+export interface RunFailureEvidence {
+  /** The run's structured failure record, or null when it did not fail (or recorded nothing). */
+  failure: AgentFailure | null
+  /** The most recent call that FAILED outright, or null when none did. */
+  lastErroredCall: LlmCallMetric | null
+  /** How many of the run's loaded calls failed outright. */
+  erroredCallCount: number
+  /** The last tool call that reported failure, or null when none did. */
+  lastFailedToolCall: AgentToolCall | null
+  /**
+   * How many of the run's tool calls reported failure — the SQL aggregate over the whole run,
+   * not the length of any list held here.
+   *
+   * This is the number that must not be counted off the trajectory. That read is a bounded
+   * PREFIX, so a run whose failures came after its opening moves would be counted at zero, which
+   * is the confident all-clear this whole section exists to refuse.
+   */
+  failedToolCallCount: number
+  /**
+   * Whether {@link lastFailedToolCall} was picked from a bounded slice of the run's failures
+   * rather than all of them, so a "last" that is only the last one HELD says so.
+   */
+  failedToolCallsTruncated: boolean
+  /** What each sink was able to say. See {@link SinkAnswer}. */
+  calls: SinkAnswer
+  tools: SinkAnswer
+}
+
+/**
+ * Fold a run's failure record and its two telemetry sinks into the evidence the panel pins.
+ *
+ * The model calls arrive NEWEST-first (the metrics list's own order) and the tool-call failures
+ * OLDEST-first (trajectory order), so "the last one that failed" is the FIRST match in one and
+ * the LAST in the other. Reading either in the wrong direction still returns a failing call,
+ * which is why it is worth stating: it would just be the wrong one, and the row nearest the
+ * failure is the whole reason to pin one at all.
+ *
+ * The tool side is handed the run's FAILURES and its exact count, never the trajectory: the two
+ * are separate reads precisely so the count here is about the run rather than about the prefix
+ * the browse tab happens to be holding.
+ */
+export function deriveRunFailureEvidence(input: {
+  failure?: AgentFailure | null
+  calls: readonly LlmCallMetric[]
+  callsAnswer: SinkAnswer
+  toolFailures: RunToolCallFailures | null
+  toolsAnswer: SinkAnswer
+}): RunFailureEvidence {
+  const errored = input.calls.filter((call) => !call.ok)
+  const failures = input.toolFailures?.failures ?? []
+  return {
+    failure: input.failure ?? null,
+    lastErroredCall: errored[0] ?? null,
+    erroredCallCount: errored.length,
+    lastFailedToolCall: failures[failures.length - 1] ?? null,
+    failedToolCallCount: input.toolFailures?.failed ?? 0,
+    failedToolCallsTruncated: input.toolFailures?.failuresTruncated ?? false,
+    calls: input.callsAnswer,
+    tools: input.toolsAnswer,
+  }
+}
+
+/**
+ * Whether the pinned failure section has anything to say about this run.
+ *
+ * An UNREACHABLE sink counts: "part of this run's telemetry could not be read" is exactly the
+ * kind of thing an operator must be told before they conclude anything from the rest of the
+ * page, and staying silent about it is how the page's other numbers get believed whole.
+ */
+export function hasFailureEvidence(evidence: RunFailureEvidence): boolean {
+  return (
+    !!evidence.failure ||
+    evidence.erroredCallCount > 0 ||
+    evidence.failedToolCallCount > 0 ||
+    evidence.calls.status === 'unreachable' ||
+    evidence.tools.status === 'unreachable'
+  )
+}
+
+/**
+ * Why the pinned section can point at no failing call, as a discriminated reason rather than a
+ * bare absence. Each needs different words and a different next step from the operator:
+ *
+ * - `sink-unreachable`: a read FAILED, so nothing can be concluded. Named first because it
+ *   OUTRANKS every statement below: each of those is a claim about the run, and this is the one
+ *   case where the panel does not have the standing to make one.
+ * - `recorded-clean`: both sinks answered, both hold rows, and none of them failed — so the
+ *   cause sits where no producer records anything (the engine, or a container that died between
+ *   calls).
+ * - `no-telemetry`: both answered and neither holds a row, so the run failed before (or outside
+ *   of) any agent work, and this panel is the wrong place to look.
+ * - `partial-calls-only` / `partial-tools-only`: both answered but only one holds rows, named by
+ *   the one that DID. Which sink is empty matters, because an empty sink is not evidence of
+ *   anything and the panel must not let it read as a clean bill.
+ *
+ * Null when a failing call WAS found (nothing to explain) or while a sink is still loading (an
+ * answer nobody has given yet must never be reported as one that came back clean).
+ */
+export type NoFailingCallReason =
+  | 'sink-unreachable'
+  | 'recorded-clean'
+  | 'no-telemetry'
+  | 'partial-calls-only'
+  | 'partial-tools-only'
+
+/** Why nothing failing could be pinned, or null when something was (or nothing is settled). */
+export function noFailingCallReason(evidence: RunFailureEvidence): NoFailingCallReason | null {
+  if (evidence.calls.status === 'unreachable' || evidence.tools.status === 'unreachable') {
+    return 'sink-unreachable'
+  }
+  if (evidence.erroredCallCount > 0 || evidence.failedToolCallCount > 0) return null
+  if (evidence.calls.status === 'pending' || evidence.tools.status === 'pending') return null
+  const hasCalls = answeredWithRows(evidence.calls)
+  const hasTools = answeredWithRows(evidence.tools)
+  if (hasCalls && hasTools) return 'recorded-clean'
+  if (hasCalls) return 'partial-calls-only'
+  if (hasTools) return 'partial-tools-only'
+  return 'no-telemetry'
+}
+
 /** Tailwind text/bg colour for an output-headroom level (green → amber → red). */
 export function headroomColor(ratio: number | null, truncated: boolean): string {
   if (truncated || (ratio != null && ratio >= 0.98)) return 'text-rose-400'

package/i18n/locales/de.json

@@ -3487,6 +3487,51 @@
       "provider": "Provider",
       "resultsCount": "{count} Ergebnis | {count} Ergebnisse",
       "queriesTitle": "Durchgeführte Suchen"
+    },
+    "callsTitle": "Modellaufrufe",
+    "noCallsMatching": "Keine Modellaufrufe entsprechen diesem Filter.",
+    "filter": {
+      "all": "Alle",
+      "failed": "Fehlgeschlagen",
+      "warning": "Abgeschnitten",
+      "ok": "OK"
+    },
+    "failure": {
+      "title": "Was fehlgeschlagen ist",
+      "kind": "Fehler: {kind}",
+      "atStep": "bei Schritt {index}",
+      "lastErroredCall": "Letzter fehlgeschlagener Modellaufruf",
+      "moreErroredCalls": "und {count} weiterer früherer fehlgeschlagener Aufruf | und {count} weitere frühere fehlgeschlagene Aufrufe",
+      "lastFailedToolCall": "Letzter fehlgeschlagener Werkzeugaufruf",
+      "aFailedToolCall": "Ein fehlgeschlagener Tool-Aufruf",
+      "moreFailedToolCalls": "und {count} weiterer früherer fehlgeschlagener Werkzeugaufruf | und {count} weitere frühere fehlgeschlagene Werkzeugaufrufe",
+      "toolReturnedNothing": "Das Werkzeug hat nichts zurückgegeben.",
+      "toolBodiesWithheld": "Argumente und Ergebnisse wurden für diesen Lauf nicht erfasst, daher liegt der Fehlertext des Werkzeugs nicht vor.",
+      "noFailingCall": {
+        "sink-unreachable": "Ein Teil der Telemetrie dieses Laufs konnte nicht geladen werden, daher lässt sich nicht sagen, was fehlgeschlagen ist.",
+        "recorded-clean": "Weder ein Modellaufruf noch ein Werkzeugaufruf meldet einen Fehler, die Ursache hat also in keiner der beiden Quellen einen Eintrag hinterlassen: Sehen Sie in der Engine, im Container-Obduktionsbericht des fehlgeschlagenen Schritts und im Bereitstellungsprotokoll nach.",
+        "partial-calls-only": "Kein Modellaufruf meldet einen Fehler, und für diesen Lauf wurden keine Werkzeugaufrufe aufgezeichnet, daher kann der Verlauf dazu nichts sagen.",
+        "partial-tools-only": "Kein Werkzeugaufruf meldet einen Fehler, und für diesen Lauf wurden keine Modellaufrufe aufgezeichnet.",
+        "no-telemetry": "Für diesen Lauf wurden weder Modellaufrufe noch Werkzeugaufrufe aufgezeichnet, er ist also vor (oder außerhalb) jeder Agentenarbeit fehlgeschlagen. Prüfen Sie das Bereitstellungsprotokoll."
+      }
+    },
+    "toolCalls": {
+      "title": "Werkzeugaufrufe",
+      "subtitle": "was die Agenten getan haben, in der Reihenfolge, in der sie es taten",
+      "loading": "Werkzeugaufrufe werden geladen…",
+      "error": "Die Werkzeugaufrufe konnten nicht geladen werden.",
+      "none": "Für diesen Lauf wurden keine Werkzeugaufrufe aufgezeichnet.",
+      "noneMatching": "Keine Werkzeugaufrufe entsprechen diesem Filter.",
+      "failed": "Fehlgeschlagen",
+      "durationHint": "Wie lange das Werkzeug gebraucht hat",
+      "dispatch": "Auftrag {jobId}",
+      "seq": "Aufruf #{seq} dieses Auftrags",
+      "bodiesWithheld": "Argumente und Ergebnisse wurden nicht erfasst, aus ihrem Fehlen lässt sich also nichts schließen.",
+      "arguments": "Argumente",
+      "result": "Ergebnis",
+      "dropped": "{chars} Zeichen bei der Erfassung verworfen",
+      "truncated": "Es werden die ersten {shown} Aufrufe dieses Laufs angezeigt. Die Zahlen oben gelten für den gesamten Lauf; filtere auf die Fehlschläge, um alle zu sehen.",
+      "failuresTruncated": "Es werden die ersten {shown} fehlgeschlagenen Aufrufe angezeigt. Die Zahl oben gilt für den gesamten Lauf."
     }
   },
   "platformObservability": {

package/i18n/locales/en.json

@@ -1727,6 +1727,51 @@
       "provider": "Provider",
       "resultsCount": "{count} result | {count} results",
       "queriesTitle": "Performed searches"
+    },
+    "callsTitle": "Model calls",
+    "noCallsMatching": "No model calls match this filter.",
+    "filter": {
+      "all": "All",
+      "failed": "Failed",
+      "warning": "Cut short",
+      "ok": "OK"
+    },
+    "failure": {
+      "title": "What failed",
+      "kind": "Failure: {kind}",
+      "atStep": "at step {index}",
+      "lastErroredCall": "Last failed model call",
+      "moreErroredCalls": "and {count} earlier failed call | and {count} earlier failed calls",
+      "lastFailedToolCall": "Last failed tool call",
+      "aFailedToolCall": "A failed tool call",
+      "moreFailedToolCalls": "and {count} earlier failed tool call | and {count} earlier failed tool calls",
+      "toolReturnedNothing": "The tool returned nothing.",
+      "toolBodiesWithheld": "Arguments and results were not captured for this run, so the tool's own error text is not available.",
+      "noFailingCall": {
+        "sink-unreachable": "Part of this run's telemetry could not be loaded, so nothing can be concluded about what failed.",
+        "recorded-clean": "No model call and no tool call reported failure, so the cause left no row in either sink: look at the engine, the container post-mortem on the failing step, and the provisioning log.",
+        "partial-calls-only": "No model call reported failure, and no tool calls were recorded for this run, so the trajectory cannot say whether one did.",
+        "partial-tools-only": "No tool call reported failure, and no model calls were recorded for this run.",
+        "no-telemetry": "Neither model calls nor tool calls were recorded for this run, so it failed before (or outside of) any agent work. Check the provisioning log."
+      }
+    },
+    "toolCalls": {
+      "title": "Tool calls",
+      "subtitle": "what the agents did, in the order they did it",
+      "loading": "Loading tool calls…",
+      "error": "Could not load the tool calls.",
+      "none": "No tool calls recorded for this run.",
+      "noneMatching": "No tool calls match this filter.",
+      "failed": "Failed",
+      "durationHint": "How long the tool took",
+      "dispatch": "Dispatch {jobId}",
+      "seq": "Call #{seq} of this dispatch",
+      "bodiesWithheld": "Arguments and results were not captured, so nothing can be concluded from their absence.",
+      "arguments": "Arguments",
+      "result": "Result",
+      "dropped": "{chars} characters dropped at capture",
+      "truncated": "Showing the first {shown} calls of this run. The counts above are for the whole run; narrow to the failures to see all of them.",
+      "failuresTruncated": "Showing the first {shown} failing calls. The count above is for the whole run."
     }
   },
   "platformObservability": {

package/i18n/locales/es.json

@@ -1632,6 +1632,51 @@
       "provider": "Proveedor",
       "resultsCount": "{count} resultado | {count} resultados",
       "queriesTitle": "Búsquedas realizadas"
+    },
+    "callsTitle": "Llamadas al modelo",
+    "noCallsMatching": "Ninguna llamada al modelo coincide con este filtro.",
+    "filter": {
+      "all": "Todas",
+      "failed": "Fallidas",
+      "warning": "Truncadas",
+      "ok": "Correctas"
+    },
+    "failure": {
+      "title": "Qué falló",
+      "kind": "Fallo: {kind}",
+      "atStep": "en el paso {index}",
+      "lastErroredCall": "Última llamada al modelo fallida",
+      "moreErroredCalls": "y {count} llamada fallida anterior | y {count} llamadas fallidas anteriores",
+      "lastFailedToolCall": "Última llamada a herramienta fallida",
+      "aFailedToolCall": "Una llamada de herramienta fallida",
+      "moreFailedToolCalls": "y {count} llamada a herramienta fallida anterior | y {count} llamadas a herramienta fallidas anteriores",
+      "toolReturnedNothing": "La herramienta no devolvió nada.",
+      "toolBodiesWithheld": "Los argumentos y resultados no se capturaron en esta ejecución, así que no se dispone del texto de error de la herramienta.",
+      "noFailingCall": {
+        "sink-unreachable": "No se pudo cargar parte de la telemetría de esta ejecución, así que no se puede concluir nada sobre qué falló.",
+        "recorded-clean": "Ninguna llamada al modelo ni a herramientas informó de un fallo, así que la causa no dejó ningún registro en ninguna de las dos fuentes: revise el motor, la autopsia del contenedor del paso fallido y el registro de aprovisionamiento.",
+        "partial-calls-only": "Ninguna llamada al modelo informó de un fallo, y no se registraron llamadas a herramientas en esta ejecución, así que la trayectoria no puede decir si alguna falló.",
+        "partial-tools-only": "Ninguna llamada a herramienta informó de un fallo, y no se registraron llamadas al modelo en esta ejecución.",
+        "no-telemetry": "No se registraron llamadas al modelo ni a herramientas en esta ejecución, así que falló antes de (o fuera de) todo trabajo de agente. Revise el registro de aprovisionamiento."
+      }
+    },
+    "toolCalls": {
+      "title": "Llamadas a herramientas",
+      "subtitle": "lo que hicieron los agentes, en el orden en que lo hicieron",
+      "loading": "Cargando llamadas a herramientas…",
+      "error": "No se pudieron cargar las llamadas a herramientas.",
+      "none": "No se registraron llamadas a herramientas en esta ejecución.",
+      "noneMatching": "Ninguna llamada a herramienta coincide con este filtro.",
+      "failed": "Fallida",
+      "durationHint": "Cuánto tardó la herramienta",
+      "dispatch": "Despacho {jobId}",
+      "seq": "Llamada n.º {seq} de este despacho",
+      "bodiesWithheld": "Los argumentos y resultados no se capturaron, así que su ausencia no permite concluir nada.",
+      "arguments": "Argumentos",
+      "result": "Resultado",
+      "dropped": "{chars} caracteres descartados al capturar",
+      "truncated": "Se muestran las primeras {shown} llamadas de esta ejecución. Los recuentos de arriba corresponden a la ejecución completa; filtra por los fallos para verlos todos.",
+      "failuresTruncated": "Se muestran las primeras {shown} llamadas fallidas. El recuento de arriba corresponde a la ejecución completa."
     }
   },
   "platformObservability": {

package/i18n/locales/fr.json

@@ -1632,6 +1632,51 @@
       "provider": "Fournisseur",
       "resultsCount": "{count} résultat | {count} résultats",
       "queriesTitle": "Recherches effectuées"
+    },
+    "callsTitle": "Appels de modèle",
+    "noCallsMatching": "Aucun appel de modèle ne correspond à ce filtre.",
+    "filter": {
+      "all": "Tous",
+      "failed": "En échec",
+      "warning": "Tronqués",
+      "ok": "OK"
+    },
+    "failure": {
+      "title": "Ce qui a échoué",
+      "kind": "Échec : {kind}",
+      "atStep": "à l'étape {index}",
+      "lastErroredCall": "Dernier appel de modèle en échec",
+      "moreErroredCalls": "et {count} appel en échec antérieur | et {count} appels en échec antérieurs",
+      "lastFailedToolCall": "Dernier appel d'outil en échec",
+      "aFailedToolCall": "Un appel d'outil en échec",
+      "moreFailedToolCalls": "et {count} appel d'outil en échec antérieur | et {count} appels d'outil en échec antérieurs",
+      "toolReturnedNothing": "L'outil n'a rien renvoyé.",
+      "toolBodiesWithheld": "Les arguments et les résultats n'ont pas été capturés pour cette exécution, le texte d'erreur de l'outil n'est donc pas disponible.",
+      "noFailingCall": {
+        "sink-unreachable": "Une partie de la télémétrie de cette exécution n'a pas pu être chargée : rien ne peut être conclu sur ce qui a échoué.",
+        "recorded-clean": "Aucun appel de modèle ni d'outil ne signale d'échec : la cause n'a laissé de trace dans aucune des deux sources. Regardez du côté du moteur, de l'autopsie du conteneur de l'étape en échec et du journal de provisionnement.",
+        "partial-calls-only": "Aucun appel de modèle ne signale d'échec, et aucun appel d'outil n'a été enregistré pour cette exécution : la trajectoire ne peut donc pas répondre.",
+        "partial-tools-only": "Aucun appel d'outil ne signale d'échec, et aucun appel de modèle n'a été enregistré pour cette exécution.",
+        "no-telemetry": "Ni appels de modèle ni appels d'outil n'ont été enregistrés pour cette exécution : elle a échoué avant (ou en dehors de) tout travail d'agent. Consultez le journal de provisionnement."
+      }
+    },
+    "toolCalls": {
+      "title": "Appels d'outils",
+      "subtitle": "ce que les agents ont fait, dans l'ordre où ils l'ont fait",
+      "loading": "Chargement des appels d'outils…",
+      "error": "Impossible de charger les appels d'outils.",
+      "none": "Aucun appel d'outil enregistré pour cette exécution.",
+      "noneMatching": "Aucun appel d'outil ne correspond à ce filtre.",
+      "failed": "En échec",
+      "durationHint": "Durée de l'appel d'outil",
+      "dispatch": "Envoi {jobId}",
+      "seq": "Appel n° {seq} de cet envoi",
+      "bodiesWithheld": "Les arguments et les résultats n'ont pas été capturés : leur absence ne permet donc rien de conclure.",
+      "arguments": "Arguments",
+      "result": "Résultat",
+      "dropped": "{chars} caractères supprimés à la capture",
+      "truncated": "Affichage des {shown} premiers appels de cette exécution. Les compteurs ci-dessus portent sur l'exécution entière ; filtrez sur les échecs pour tous les voir.",
+      "failuresTruncated": "Affichage des {shown} premiers appels en échec. Le compteur ci-dessus porte sur l'exécution entière."
     }
   },
   "platformObservability": {

package/i18n/locales/he.json

@@ -1632,6 +1632,51 @@
       "provider": "ספק",
       "resultsCount": "תוצאה אחת | שתי תוצאות | {count} תוצאות",
       "queriesTitle": "חיפושים שבוצעו"
+    },
+    "callsTitle": "קריאות מודל",
+    "noCallsMatching": "אין קריאות מודל התואמות למסנן זה.",
+    "filter": {
+      "all": "הכול",
+      "failed": "נכשלו",
+      "warning": "נקטעו",
+      "ok": "תקינות"
+    },
+    "failure": {
+      "title": "מה נכשל",
+      "kind": "כשל: {kind}",
+      "atStep": "בשלב {index}",
+      "lastErroredCall": "קריאת המודל האחרונה שנכשלה",
+      "moreErroredCalls": "ועוד קריאה קודמת אחת שנכשלה | ועוד שתי קריאות קודמות שנכשלו | ועוד {count} קריאות קודמות שנכשלו",
+      "lastFailedToolCall": "קריאת הכלי האחרונה שנכשלה",
+      "aFailedToolCall": "קריאת כלי שנכשלה",
+      "moreFailedToolCalls": "ועוד קריאת כלי קודמת אחת שנכשלה | ועוד שתי קריאות כלי קודמות שנכשלו | ועוד {count} קריאות כלי קודמות שנכשלו",
+      "toolReturnedNothing": "הכלי לא החזיר דבר.",
+      "toolBodiesWithheld": "ארגומנטים ותוצאות לא נלכדו עבור ריצה זו, ולכן טקסט השגיאה של הכלי אינו זמין.",
+      "noFailingCall": {
+        "sink-unreachable": "חלק מהטלמטריה של הריצה הזו לא נטען, ולכן אי אפשר להסיק דבר לגבי מה נכשל.",
+        "recorded-clean": "אף קריאת מודל ואף קריאת כלי לא דיווחו על כשל, כך שהסיבה לא הותירה רשומה באף אחד מהמקורות: בדקו את המנוע, את דוח הנתיחה של המכולה בשלב שנכשל ואת יומן ההקצאה.",
+        "partial-calls-only": "אף קריאת מודל לא דיווחה על כשל, ולא נרשמו קריאות כלי עבור ריצה זו, ולכן המסלול אינו יכול לענות על כך.",
+        "partial-tools-only": "אף קריאת כלי לא דיווחה על כשל, ולא נרשמו קריאות מודל עבור ריצה זו.",
+        "no-telemetry": "לא נרשמו עבור ריצה זו לא קריאות מודל ולא קריאות כלי, ולכן היא נכשלה לפני כל עבודת סוכן (או מחוץ לה). בדקו את יומן ההקצאה."
+      }
+    },
+    "toolCalls": {
+      "title": "קריאות כלים",
+      "subtitle": "מה הסוכנים עשו, בסדר שבו עשו זאת",
+      "loading": "טוען קריאות כלים…",
+      "error": "לא ניתן לטעון את קריאות הכלים.",
+      "none": "לא נרשמו קריאות כלים עבור ריצה זו.",
+      "noneMatching": "אין קריאות כלים התואמות למסנן זה.",
+      "failed": "נכשלה",
+      "durationHint": "כמה זמן ארך הכלי",
+      "dispatch": "שיגור {jobId}",
+      "seq": "קריאה מס׳ {seq} בשיגור זה",
+      "bodiesWithheld": "ארגומנטים ותוצאות לא נלכדו, ולכן אי אפשר להסיק דבר מהיעדרם.",
+      "arguments": "ארגומנטים",
+      "result": "תוצאה",
+      "dropped": "{chars} תווים הושמטו בעת הלכידה",
+      "truncated": "מוצגות {shown} הקריאות הראשונות של הריצה. המספרים למעלה מתייחסים לריצה כולה; סננו לכשלים כדי לראות את כולם.",
+      "failuresTruncated": "מוצגות {shown} הקריאות הכושלות הראשונות. המספר למעלה מתייחס לריצה כולה."
     }
   },
   "platformObservability": {

package/i18n/locales/it.json

@@ -3487,6 +3487,51 @@
       "provider": "Provider",
       "resultsCount": "{count} risultato | {count} risultati",
       "queriesTitle": "Ricerche effettuate"
+    },
+    "callsTitle": "Chiamate al modello",
+    "noCallsMatching": "Nessuna chiamata al modello corrisponde a questo filtro.",
+    "filter": {
+      "all": "Tutte",
+      "failed": "Fallite",
+      "warning": "Troncate",
+      "ok": "OK"
+    },
+    "failure": {
+      "title": "Che cosa è fallito",
+      "kind": "Errore: {kind}",
+      "atStep": "al passo {index}",
+      "lastErroredCall": "Ultima chiamata al modello fallita",
+      "moreErroredCalls": "e {count} chiamata fallita precedente | e {count} chiamate fallite precedenti",
+      "lastFailedToolCall": "Ultima chiamata a strumento fallita",
+      "aFailedToolCall": "Una chiamata di strumento fallita",
+      "moreFailedToolCalls": "e {count} chiamata a strumento fallita precedente | e {count} chiamate a strumento fallite precedenti",
+      "toolReturnedNothing": "Lo strumento non ha restituito nulla.",
+      "toolBodiesWithheld": "Argomenti e risultati non sono stati acquisiti per questa esecuzione, quindi il testo dell'errore dello strumento non è disponibile.",
+      "noFailingCall": {
+        "sink-unreachable": "Parte della telemetria di questa esecuzione non è stata caricata, quindi non si può concludere nulla su cosa sia fallito.",
+        "recorded-clean": "Nessuna chiamata al modello e nessuna chiamata a strumento ha segnalato un errore, quindi la causa non ha lasciato righe in nessuna delle due fonti: guardate il motore, l'autopsia del container del passo fallito e il registro di provisioning.",
+        "partial-calls-only": "Nessuna chiamata al modello ha segnalato un errore e per questa esecuzione non sono state registrate chiamate a strumenti, quindi la traiettoria non può rispondere.",
+        "partial-tools-only": "Nessuna chiamata a strumento ha segnalato un errore e per questa esecuzione non sono state registrate chiamate al modello.",
+        "no-telemetry": "Per questa esecuzione non sono state registrate né chiamate al modello né chiamate a strumenti, quindi è fallita prima (o al di fuori) di qualsiasi lavoro dell'agente. Controllate il registro di provisioning."
+      }
+    },
+    "toolCalls": {
+      "title": "Chiamate a strumenti",
+      "subtitle": "che cosa hanno fatto gli agenti, nell'ordine in cui l'hanno fatto",
+      "loading": "Caricamento delle chiamate a strumenti…",
+      "error": "Impossibile caricare le chiamate a strumenti.",
+      "none": "Nessuna chiamata a strumento registrata per questa esecuzione.",
+      "noneMatching": "Nessuna chiamata a strumento corrisponde a questo filtro.",
+      "failed": "Fallita",
+      "durationHint": "Quanto è durato lo strumento",
+      "dispatch": "Invio {jobId}",
+      "seq": "Chiamata n. {seq} di questo invio",
+      "bodiesWithheld": "Argomenti e risultati non sono stati acquisiti, quindi dalla loro assenza non si può concludere nulla.",
+      "arguments": "Argomenti",
+      "result": "Risultato",
+      "dropped": "{chars} caratteri scartati all'acquisizione",
+      "truncated": "Sono mostrate le prime {shown} chiamate di questa esecuzione. I conteggi sopra si riferiscono all'intera esecuzione; filtra sui fallimenti per vederli tutti.",
+      "failuresTruncated": "Sono mostrate le prime {shown} chiamate fallite. Il conteggio sopra si riferisce all'intera esecuzione."
     }
   },
   "platformObservability": {

package/i18n/locales/ja.json

@@ -1632,6 +1632,51 @@
       "provider": "プロバイダー",
       "resultsCount": "{count} 件の結果 | {count} 件の結果",
       "queriesTitle": "実行した検索"
+    },
+    "callsTitle": "モデル呼び出し",
+    "noCallsMatching": "このフィルターに一致するモデル呼び出しはありません。",
+    "filter": {
+      "all": "すべて",
+      "failed": "失敗",
+      "warning": "打ち切り",
+      "ok": "正常"
+    },
+    "failure": {
+      "title": "何が失敗したか",
+      "kind": "失敗: {kind}",
+      "atStep": "ステップ {index} で",
+      "lastErroredCall": "最後に失敗したモデル呼び出し",
+      "moreErroredCalls": "ほかに、それ以前の失敗した呼び出しが {count} 件 | ほかに、それ以前の失敗した呼び出しが {count} 件",
+      "lastFailedToolCall": "最後に失敗したツール呼び出し",
+      "aFailedToolCall": "失敗したツール呼び出し",
+      "moreFailedToolCalls": "ほかに、それ以前の失敗したツール呼び出しが {count} 件 | ほかに、それ以前の失敗したツール呼び出しが {count} 件",
+      "toolReturnedNothing": "ツールは何も返しませんでした。",
+      "toolBodiesWithheld": "この実行では引数と結果が記録されていないため、ツール自身のエラーテキストは参照できません。",
+      "noFailingCall": {
+        "sink-unreachable": "この実行のテレメトリの一部を読み込めなかったため、何が失敗したかは判断できません。",
+        "recorded-clean": "モデル呼び出しもツール呼び出しも失敗を報告していません。原因はどちらの記録にも行を残していないため、エンジン、失敗したステップのコンテナ事後解析、プロビジョニングログを確認してください。",
+        "partial-calls-only": "モデル呼び出しに失敗はなく、この実行ではツール呼び出しが記録されていないため、軌跡からは判断できません。",
+        "partial-tools-only": "ツール呼び出しに失敗はなく、この実行ではモデル呼び出しが記録されていません。",
+        "no-telemetry": "この実行ではモデル呼び出しもツール呼び出しも記録されていないため、エージェントの作業の前（または外）で失敗しています。プロビジョニングログを確認してください。"
+      }
+    },
+    "toolCalls": {
+      "title": "ツール呼び出し",
+      "subtitle": "エージェントが行ったことを、行った順に",
+      "loading": "ツール呼び出しを読み込んでいます…",
+      "error": "ツール呼び出しを読み込めませんでした。",
+      "none": "この実行で記録されたツール呼び出しはありません。",
+      "noneMatching": "このフィルターに一致するツール呼び出しはありません。",
+      "failed": "失敗",
+      "durationHint": "ツールの所要時間",
+      "dispatch": "ディスパッチ {jobId}",
+      "seq": "このディスパッチの {seq} 番目の呼び出し",
+      "bodiesWithheld": "引数と結果は記録されていないため、その不在からは何も判断できません。",
+      "arguments": "引数",
+      "result": "結果",
+      "dropped": "記録時に {chars} 文字を破棄",
+      "truncated": "この実行の最初の {shown} 件の呼び出しを表示しています。上の件数は実行全体のものです。すべての失敗を見るには失敗で絞り込んでください。",
+      "failuresTruncated": "最初の {shown} 件の失敗した呼び出しを表示しています。上の件数は実行全体のものです。"
     }
   },
   "platformObservability": {