@cat-factory/app 0.232.2 → 0.234.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

@@ -353,6 +353,13 @@
         "manageAccount": "Kontofragmente verwalten →"
       }
     },
+    "taskTypeSuppressions": {
+      "intro": "Wählen Sie aus, welche wiederverwendbaren Operationen dieses Deployments auf diesem Board angeboten werden. Wird eine ausgeblendet, verschwindet sie hier aus der Aufgabenauswahl und das Anlegen von Arbeit darunter wird abgelehnt; andere Boards bleiben unberührt.",
+      "loading": "Operationen werden geladen…",
+      "empty": "Dieses Deployment registriert keine wiederverwendbaren Operationen.",
+      "offer": "Auf diesem Board anbieten",
+      "saveFailed": "Die angebotenen Operationen konnten nicht geändert werden"
+    },
     "issueTracker": {
       "filing": {
         "heading": "Wo Tickets abgelegt werden",
@@ -932,6 +939,7 @@
         "merge": "Risikorichtlinien",
         "tracker": "Issue-Tracker",
         "fragments": "Dienst-Best-Practices",
+        "operations": "Operationen",
         "metadata": "Metadaten",
         "members": "Mitglieder"
       },
@@ -3487,6 +3495,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": {
@@ -2869,6 +2914,13 @@
         "manageAccount": "Manage account fragments →"
       }
     },
+    "taskTypeSuppressions": {
+      "intro": "Choose which of this deployment's reusable operations this board offers. Hiding one removes it from the create-task picker here and refuses creating work under it; other boards are unaffected.",
+      "loading": "Loading operations…",
+      "empty": "This deployment registers no reusable operations.",
+      "offer": "Offer on this board",
+      "saveFailed": "Could not change which operations this board offers"
+    },
     "issueTracker": {
       "filing": {
         "heading": "Where tickets are filed",
@@ -3457,6 +3509,7 @@
         "merge": "Risk policies",
         "tracker": "Issue tracker",
         "fragments": "Service best practices",
+        "operations": "Operations",
         "metadata": "Metadata",
         "members": "Members"
       },

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": {
@@ -2621,6 +2666,13 @@
         "manageAccount": "Gestionar los fragmentos de la cuenta →"
       }
     },
+    "taskTypeSuppressions": {
+      "intro": "Elige qué operaciones reutilizables de este despliegue ofrece este tablero. Ocultar una la quita del selector de creación de tareas aquí y rechaza crear trabajo con ella; otros tableros no se ven afectados.",
+      "loading": "Cargando operaciones…",
+      "empty": "Este despliegue no registra ninguna operación reutilizable.",
+      "offer": "Ofrecer en este tablero",
+      "saveFailed": "No se pudieron cambiar las operaciones que ofrece este tablero"
+    },
     "issueTracker": {
       "filing": {
         "heading": "Dónde se registran los tickets",
@@ -3200,6 +3252,7 @@
         "merge": "Políticas de riesgo",
         "tracker": "Gestor de incidencias",
         "fragments": "Buenas prácticas del servicio",
+        "operations": "Operaciones",
         "metadata": "Metadatos",
         "members": "Miembros"
       },

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": {
@@ -2621,6 +2666,13 @@
         "manageAccount": "Gérer les fragments du compte →"
       }
     },
+    "taskTypeSuppressions": {
+      "intro": "Choisissez les opérations réutilisables de ce déploiement proposées sur ce tableau. En masquer une la retire du sélecteur de création de tâche ici et refuse la création de travail associée ; les autres tableaux ne sont pas affectés.",
+      "loading": "Chargement des opérations…",
+      "empty": "Ce déploiement n'enregistre aucune opération réutilisable.",
+      "offer": "Proposer sur ce tableau",
+      "saveFailed": "Impossible de modifier les opérations proposées sur ce tableau"
+    },
     "issueTracker": {
       "filing": {
         "heading": "Où les tickets sont créés",
@@ -3200,6 +3252,7 @@
         "merge": "Politiques de risque",
         "tracker": "Suivi des tickets",
         "fragments": "Bonnes pratiques du service",
+        "operations": "Opérations",
         "metadata": "Métadonnées",
         "members": "Membres"
       },

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": {
@@ -2762,6 +2807,13 @@
         "manageAccount": "נהל מקטעי חשבון ←"
       }
     },
+    "taskTypeSuppressions": {
+      "intro": "בחרו אילו פעולות רב-פעמיות של פריסה זו יוצעו בלוח הזה. הסתרה של פעולה מסירה אותה מבורר יצירת המשימות כאן ומונעת יצירת עבודה תחתיה; לוחות אחרים אינם מושפעים.",
+      "loading": "טוען פעולות…",
+      "empty": "פריסה זו אינה רושמת פעולות רב-פעמיות.",
+      "offer": "הצעה בלוח הזה",
+      "saveFailed": "לא ניתן היה לשנות אילו פעולות מוצעות בלוח הזה"
+    },
     "issueTracker": {
       "filing": {
         "heading": "היכן מוגשים כרטיסים",
@@ -3341,6 +3393,7 @@
         "merge": "מדיניות סיכון",
         "tracker": "מעקב כרטיסים",
         "fragments": "שיטות עבודה מומלצות לשירות",
+        "operations": "פעולות",
         "metadata": "מטא-נתונים",
         "members": "חברים"
       },