@meetkai/mka1 0.54.67 → 0.54.69

package/src/models/components/appendagenttrialsrequest.ts

@@ -57,6 +57,13 @@ export type AppendAgentTrialsRequestTrials = {
    * The share of `input_tokens` served from the provider's prompt cache.
    */
   cachedTokens?: number | null | undefined;
+  /**
+   * The share of `output_tokens` the provider attributed to reasoning. Null when it reported no split.
+   */
+  reasoningTokens?: number | null | undefined;
+  /**
+   * Wall time per phase as `{ phase: { started_at, finished_at } }` (ISO 8601). A harness trial carries its Harbor phases; a sample the gateway generated carries `generation`, the model call itself.
+   */
   phaseTimings?: { [k: string]: any } | null | undefined;
 };
 
@@ -98,6 +105,7 @@ export const AppendAgentTrialsRequestTrials$inboundSchema: z.ZodType<
   input_tokens: z.nullable(z.number().int()).optional(),
   output_tokens: z.nullable(z.number().int()).optional(),
   cached_tokens: z.nullable(z.number().int()).optional(),
+  reasoning_tokens: z.nullable(z.number().int()).optional(),
   phase_timings: z.nullable(z.record(z.any())).optional(),
 }).transform((v) => {
   return remap$(v, {
@@ -108,6 +116,7 @@ export const AppendAgentTrialsRequestTrials$inboundSchema: z.ZodType<
     "input_tokens": "inputTokens",
     "output_tokens": "outputTokens",
     "cached_tokens": "cachedTokens",
+    "reasoning_tokens": "reasoningTokens",
     "phase_timings": "phaseTimings",
   });
 });
@@ -125,6 +134,7 @@ export type AppendAgentTrialsRequestTrials$Outbound = {
   input_tokens?: number | null | undefined;
   output_tokens?: number | null | undefined;
   cached_tokens?: number | null | undefined;
+  reasoning_tokens?: number | null | undefined;
   phase_timings?: { [k: string]: any } | null | undefined;
 };
 
@@ -146,6 +156,7 @@ export const AppendAgentTrialsRequestTrials$outboundSchema: z.ZodType<
   inputTokens: z.nullable(z.number().int()).optional(),
   outputTokens: z.nullable(z.number().int()).optional(),
   cachedTokens: z.nullable(z.number().int()).optional(),
+  reasoningTokens: z.nullable(z.number().int()).optional(),
   phaseTimings: z.nullable(z.record(z.any())).optional(),
 }).transform((v) => {
   return remap$(v, {
@@ -156,6 +167,7 @@ export const AppendAgentTrialsRequestTrials$outboundSchema: z.ZodType<
     inputTokens: "input_tokens",
     outputTokens: "output_tokens",
     cachedTokens: "cached_tokens",
+    reasoningTokens: "reasoning_tokens",
     phaseTimings: "phase_timings",
   });
 });

package/src/models/components/computelog.ts

@@ -22,12 +22,12 @@ export const Stream = {
 export type Stream = ClosedEnum<typeof Stream>;
 
 /**
- * One line of a workload's output, or a system note about the workload. Lines are kept for 7 days.
+ * One line of a workload's output, or a system note about the workload. Lines are kept for 7 days, and each job or service keeps at most its newest 100 MB, each line counting as its text plus 400 bytes. Once the limit has deleted lines, the log starts with a system line counting them.
  */
 export type ComputeLog = {
   id: string;
   /**
-   * The node of a multi-node workload that wrote the line, 0 when it has one node. Absent on lines no run wrote, such as lines of native services, which name their replica instead.
+   * The node of a multi-node workload that wrote the line, 0 when it has one node. Absent on lines no run wrote: lines of native services, which name their replica instead, and the log limit's note.
    */
   instanceRank?: number | undefined;
   message: string;

package/src/models/components/evalleaderboardrow.ts

@@ -46,6 +46,34 @@ export type EvalLeaderboardRow = {
    * Summed trial spend, falling back to the runs' own totals when trials carry no cost. Null when neither reported any.
    */
   costUsd: number | null;
+  /**
+   * Trials where `metric` reached full credit (1). On a pass/fail board this is the solve count; on a partial-credit board it counts only the fully passing trials, not the partials. It is the denominator for cost and tokens per solved task, which is how spend should be read: an agent that gives up early is cheap per trial and buys nothing.
+   */
+  solvedTrials: number;
+  /**
+   * Prompt tokens summed over the row's trials, `cached_tokens` included. Null when no trial reported usage.
+   */
+  inputTokens: number | null;
+  /**
+   * Completion tokens summed over the row's trials. Null when no trial reported usage.
+   */
+  outputTokens: number | null;
+  /**
+   * The share of `input_tokens` served from the provider's prompt cache. Agent context is re-sent every turn, so this is most of what separates a cheap board run from an expensive one. Null when no trial reported it.
+   */
+  cachedTokens: number | null;
+  /**
+   * Agent steps summed over the row's captured sessions. Null when no trial in the row uploaded a trajectory — a trial without one contributes nothing rather than a zero, so the figure covers only the sessions actually recorded.
+   */
+  steps: number | null;
+  /**
+   * Wall seconds of the agent phase, summed over the `timed_trials` that carry Harbor's `agent_execution` timing. Null when none did.
+   */
+  agentSeconds: number | null;
+  /**
+   * Trials behind `agent_seconds`; divide by this, not by `trials`, for seconds per trial.
+   */
+  timedTrials: number;
   runCount: number;
   /**
    * The runs behind this row, largest (most trials) first, ties newest first — element 0 is the run to open when the reader drills into this row, so a full benchmark job outranks a newer one-task smoke run.
@@ -114,6 +142,13 @@ export const EvalLeaderboardRow$inboundSchema: z.ZodType<
   scored_trials: z.number().int(),
   failed_trials: z.number().int(),
   cost_usd: z.nullable(z.number()),
+  solved_trials: z.number().int(),
+  input_tokens: z.nullable(z.number().int()),
+  output_tokens: z.nullable(z.number().int()),
+  cached_tokens: z.nullable(z.number().int()),
+  steps: z.nullable(z.number().int()),
+  agent_seconds: z.nullable(z.number()),
+  timed_trials: z.number().int(),
   run_count: z.number().int(),
   run_ids: z.array(z.string()),
   last_run_at: z.number().int(),
@@ -126,6 +161,12 @@ export const EvalLeaderboardRow$inboundSchema: z.ZodType<
     "scored_trials": "scoredTrials",
     "failed_trials": "failedTrials",
     "cost_usd": "costUsd",
+    "solved_trials": "solvedTrials",
+    "input_tokens": "inputTokens",
+    "output_tokens": "outputTokens",
+    "cached_tokens": "cachedTokens",
+    "agent_seconds": "agentSeconds",
+    "timed_trials": "timedTrials",
     "run_count": "runCount",
     "run_ids": "runIds",
     "last_run_at": "lastRunAt",
@@ -143,6 +184,13 @@ export type EvalLeaderboardRow$Outbound = {
   scored_trials: number;
   failed_trials: number;
   cost_usd: number | null;
+  solved_trials: number;
+  input_tokens: number | null;
+  output_tokens: number | null;
+  cached_tokens: number | null;
+  steps: number | null;
+  agent_seconds: number | null;
+  timed_trials: number;
   run_count: number;
   run_ids: Array<string>;
   last_run_at: number;
@@ -164,6 +212,13 @@ export const EvalLeaderboardRow$outboundSchema: z.ZodType<
   scoredTrials: z.number().int(),
   failedTrials: z.number().int(),
   costUsd: z.nullable(z.number()),
+  solvedTrials: z.number().int(),
+  inputTokens: z.nullable(z.number().int()),
+  outputTokens: z.nullable(z.number().int()),
+  cachedTokens: z.nullable(z.number().int()),
+  steps: z.nullable(z.number().int()),
+  agentSeconds: z.nullable(z.number()),
+  timedTrials: z.number().int(),
   runCount: z.number().int(),
   runIds: z.array(z.string()),
   lastRunAt: z.number().int(),
@@ -176,6 +231,12 @@ export const EvalLeaderboardRow$outboundSchema: z.ZodType<
     scoredTrials: "scored_trials",
     failedTrials: "failed_trials",
     costUsd: "cost_usd",
+    solvedTrials: "solved_trials",
+    inputTokens: "input_tokens",
+    outputTokens: "output_tokens",
+    cachedTokens: "cached_tokens",
+    agentSeconds: "agent_seconds",
+    timedTrials: "timed_trials",
     runCount: "run_count",
     runIds: "run_ids",
     lastRunAt: "last_run_at",

package/src/models/components/evalrunoverview.ts

@@ -40,6 +40,10 @@ export type Tokens = {
    * Share of `input` served from the provider's prompt cache.
    */
   cached: number | null;
+  /**
+   * Reasoning tokens inside `output`, over the samples whose provider reported the split.
+   */
+  reasoning: number | null;
 };
 
 export type EvalRunOverview = {
@@ -114,12 +118,14 @@ export const Tokens$inboundSchema: z.ZodType<Tokens, z.ZodTypeDef, unknown> = z
     input: z.nullable(z.number().int()),
     output: z.nullable(z.number().int()),
     cached: z.nullable(z.number().int()),
+    reasoning: z.nullable(z.number().int()),
   });
 /** @internal */
 export type Tokens$Outbound = {
   input: number | null;
   output: number | null;
   cached: number | null;
+  reasoning: number | null;
 };
 
 /** @internal */
@@ -131,6 +137,7 @@ export const Tokens$outboundSchema: z.ZodType<
   input: z.nullable(z.number().int()),
   output: z.nullable(z.number().int()),
   cached: z.nullable(z.number().int()),
+  reasoning: z.nullable(z.number().int()),
 });
 
 export function tokensToJSON(tokens: Tokens): string {

package/src/models/components/evalsampleobject.ts

@@ -53,6 +53,10 @@ export type EvalSampleObject = {
    * The share of `input_tokens` served from the provider's prompt cache. Reported separately because it is what makes two agents at the same token count cost an order of magnitude apart.
    */
   cachedTokens: number | null;
+  /**
+   * The share of `output_tokens` the provider attributed to reasoning. Null when it reported no split.
+   */
+  reasoningTokens: number | null;
   /**
    * Per-phase wall clock for a harness trial: `environment_setup`, `agent_setup`, `agent_execution`, `verifier`, each `{ started_at, finished_at }` as ISO 8601 timestamps exactly as the harness recorded them. A phase the harness did not time is absent rather than null. Drives the trial timing bar. Null outside harness runs.
    */
@@ -89,6 +93,7 @@ export const EvalSampleObject$inboundSchema: z.ZodType<
   input_tokens: z.nullable(z.number().int()),
   output_tokens: z.nullable(z.number().int()),
   cached_tokens: z.nullable(z.number().int()),
+  reasoning_tokens: z.nullable(z.number().int()),
   phase_timings: z.nullable(z.record(z.any())),
   created_at: z.number().int(),
   started_at: z.nullable(z.number().int()),
@@ -106,6 +111,7 @@ export const EvalSampleObject$inboundSchema: z.ZodType<
     "input_tokens": "inputTokens",
     "output_tokens": "outputTokens",
     "cached_tokens": "cachedTokens",
+    "reasoning_tokens": "reasoningTokens",
     "phase_timings": "phaseTimings",
     "created_at": "createdAt",
     "started_at": "startedAt",
@@ -135,6 +141,7 @@ export type EvalSampleObject$Outbound = {
   input_tokens: number | null;
   output_tokens: number | null;
   cached_tokens: number | null;
+  reasoning_tokens: number | null;
   phase_timings: { [k: string]: any } | null;
   created_at: number;
   started_at: number | null;
@@ -168,6 +175,7 @@ export const EvalSampleObject$outboundSchema: z.ZodType<
   inputTokens: z.nullable(z.number().int()),
   outputTokens: z.nullable(z.number().int()),
   cachedTokens: z.nullable(z.number().int()),
+  reasoningTokens: z.nullable(z.number().int()),
   phaseTimings: z.nullable(z.record(z.any())),
   createdAt: z.number().int(),
   startedAt: z.nullable(z.number().int()),
@@ -185,6 +193,7 @@ export const EvalSampleObject$outboundSchema: z.ZodType<
     inputTokens: "input_tokens",
     outputTokens: "output_tokens",
     cachedTokens: "cached_tokens",
+    reasoningTokens: "reasoning_tokens",
     phaseTimings: "phase_timings",
     createdAt: "created_at",
     startedAt: "started_at",

package/src/models/components/importagentrunrequest.ts

@@ -60,6 +60,13 @@ export type ImportAgentRunRequestTrials = {
    * The share of `input_tokens` served from the provider's prompt cache.
    */
   cachedTokens?: number | null | undefined;
+  /**
+   * The share of `output_tokens` the provider attributed to reasoning. Null when it reported no split.
+   */
+  reasoningTokens?: number | null | undefined;
+  /**
+   * Wall time per phase as `{ phase: { started_at, finished_at } }` (ISO 8601). A harness trial carries its Harbor phases; a sample the gateway generated carries `generation`, the model call itself.
+   */
   phaseTimings?: { [k: string]: any } | null | undefined;
 };
 
@@ -136,6 +143,7 @@ export const ImportAgentRunRequestTrials$inboundSchema: z.ZodType<
   input_tokens: z.nullable(z.number().int()).optional(),
   output_tokens: z.nullable(z.number().int()).optional(),
   cached_tokens: z.nullable(z.number().int()).optional(),
+  reasoning_tokens: z.nullable(z.number().int()).optional(),
   phase_timings: z.nullable(z.record(z.any())).optional(),
 }).transform((v) => {
   return remap$(v, {
@@ -146,6 +154,7 @@ export const ImportAgentRunRequestTrials$inboundSchema: z.ZodType<
     "input_tokens": "inputTokens",
     "output_tokens": "outputTokens",
     "cached_tokens": "cachedTokens",
+    "reasoning_tokens": "reasoningTokens",
     "phase_timings": "phaseTimings",
   });
 });
@@ -163,6 +172,7 @@ export type ImportAgentRunRequestTrials$Outbound = {
   input_tokens?: number | null | undefined;
   output_tokens?: number | null | undefined;
   cached_tokens?: number | null | undefined;
+  reasoning_tokens?: number | null | undefined;
   phase_timings?: { [k: string]: any } | null | undefined;
 };
 
@@ -184,6 +194,7 @@ export const ImportAgentRunRequestTrials$outboundSchema: z.ZodType<
   inputTokens: z.nullable(z.number().int()).optional(),
   outputTokens: z.nullable(z.number().int()).optional(),
   cachedTokens: z.nullable(z.number().int()).optional(),
+  reasoningTokens: z.nullable(z.number().int()).optional(),
   phaseTimings: z.nullable(z.record(z.any())).optional(),
 }).transform((v) => {
   return remap$(v, {
@@ -194,6 +205,7 @@ export const ImportAgentRunRequestTrials$outboundSchema: z.ZodType<
     inputTokens: "input_tokens",
     outputTokens: "output_tokens",
     cachedTokens: "cached_tokens",
+    reasoningTokens: "reasoning_tokens",
     phaseTimings: "phase_timings",
   });
 });

package/src/models/operations/appendagentevaltrials.ts

@@ -88,6 +88,25 @@ export type AppendAgentEvalTrialsRequestCounts = {
   failed: number;
 };
 
+/**
+ * Token totals for the run, summed over its samples when it finalized. Each is null when nothing reported that figure, which is a different fact from zero and must not render as free.
+ */
+export type AppendAgentEvalTrialsTokens = {
+  /**
+   * Prompt tokens over the run's samples, `cached` included.
+   */
+  input: number | null;
+  output: number | null;
+  /**
+   * The share of `input` the provider served from its prompt cache. Can exceed `input` on an older harness import, where the two numbers came from different accountings — treat the pair as inconsistent rather than deriving a hit rate from it.
+   */
+  cached: number | null;
+  /**
+   * Reasoning tokens inside `output`, summed over the samples whose provider reported the split. Null when none did; the per-task figures in `metrics.by_task` estimate the split from the stored text in that case.
+   */
+  reasoning: number | null;
+};
+
 /**
  * OK
  */
@@ -132,6 +151,10 @@ export type AppendAgentEvalTrialsResponseBody = {
    * Total spend for the run in USD. Null when the harness did not report cost.
    */
   costUsd: number | null;
+  /**
+   * Token totals for the run, summed over its samples when it finalized. Each is null when nothing reported that figure, which is a different fact from zero and must not render as free.
+   */
+  tokens: AppendAgentEvalTrialsTokens;
   createdAt: number;
   startedAt: number | null;
   completedAt: number | null;
@@ -510,6 +533,56 @@ export function appendAgentEvalTrialsRequestCountsFromJSON(
   );
 }
 
+/** @internal */
+export const AppendAgentEvalTrialsTokens$inboundSchema: z.ZodType<
+  AppendAgentEvalTrialsTokens,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  input: z.nullable(z.number().int()),
+  output: z.nullable(z.number().int()),
+  cached: z.nullable(z.number().int()),
+  reasoning: z.nullable(z.number().int()),
+});
+/** @internal */
+export type AppendAgentEvalTrialsTokens$Outbound = {
+  input: number | null;
+  output: number | null;
+  cached: number | null;
+  reasoning: number | null;
+};
+
+/** @internal */
+export const AppendAgentEvalTrialsTokens$outboundSchema: z.ZodType<
+  AppendAgentEvalTrialsTokens$Outbound,
+  z.ZodTypeDef,
+  AppendAgentEvalTrialsTokens
+> = z.object({
+  input: z.nullable(z.number().int()),
+  output: z.nullable(z.number().int()),
+  cached: z.nullable(z.number().int()),
+  reasoning: z.nullable(z.number().int()),
+});
+
+export function appendAgentEvalTrialsTokensToJSON(
+  appendAgentEvalTrialsTokens: AppendAgentEvalTrialsTokens,
+): string {
+  return JSON.stringify(
+    AppendAgentEvalTrialsTokens$outboundSchema.parse(
+      appendAgentEvalTrialsTokens,
+    ),
+  );
+}
+export function appendAgentEvalTrialsTokensFromJSON(
+  jsonString: string,
+): SafeParseResult<AppendAgentEvalTrialsTokens, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => AppendAgentEvalTrialsTokens$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'AppendAgentEvalTrialsTokens' from JSON`,
+  );
+}
+
 /** @internal */
 export const AppendAgentEvalTrialsResponseBody$inboundSchema: z.ZodType<
   AppendAgentEvalTrialsResponseBody,
@@ -540,6 +613,7 @@ export const AppendAgentEvalTrialsResponseBody$inboundSchema: z.ZodType<
   agent_version: z.nullable(z.string()),
   agent_effort: z.nullable(z.string()),
   cost_usd: z.nullable(z.number()),
+  tokens: z.lazy(() => AppendAgentEvalTrialsTokens$inboundSchema),
   created_at: z.number().int(),
   started_at: z.nullable(z.number().int()),
   completed_at: z.nullable(z.number().int()),
@@ -592,6 +666,7 @@ export type AppendAgentEvalTrialsResponseBody$Outbound = {
   agent_version: string | null;
   agent_effort: string | null;
   cost_usd: number | null;
+  tokens: AppendAgentEvalTrialsTokens$Outbound;
   created_at: number;
   started_at: number | null;
   completed_at: number | null;
@@ -629,6 +704,7 @@ export const AppendAgentEvalTrialsResponseBody$outboundSchema: z.ZodType<
   agentVersion: z.nullable(z.string()),
   agentEffort: z.nullable(z.string()),
   costUsd: z.nullable(z.number()),
+  tokens: z.lazy(() => AppendAgentEvalTrialsTokens$outboundSchema),
   createdAt: z.number().int(),
   startedAt: z.nullable(z.number().int()),
   completedAt: z.nullable(z.number().int()),

package/src/models/operations/cancelevalrun.ts

@@ -87,6 +87,25 @@ export type CancelEvalRunRequestCounts = {
   failed: number;
 };
 
+/**
+ * Token totals for the run, summed over its samples when it finalized. Each is null when nothing reported that figure, which is a different fact from zero and must not render as free.
+ */
+export type CancelEvalRunTokens = {
+  /**
+   * Prompt tokens over the run's samples, `cached` included.
+   */
+  input: number | null;
+  output: number | null;
+  /**
+   * The share of `input` the provider served from its prompt cache. Can exceed `input` on an older harness import, where the two numbers came from different accountings — treat the pair as inconsistent rather than deriving a hit rate from it.
+   */
+  cached: number | null;
+  /**
+   * Reasoning tokens inside `output`, summed over the samples whose provider reported the split. Null when none did; the per-task figures in `metrics.by_task` estimate the split from the stored text in that case.
+   */
+  reasoning: number | null;
+};
+
 /**
  * OK
  */
@@ -131,6 +150,10 @@ export type CancelEvalRunResponseBody = {
    * Total spend for the run in USD. Null when the harness did not report cost.
    */
   costUsd: number | null;
+  /**
+   * Token totals for the run, summed over its samples when it finalized. Each is null when nothing reported that figure, which is a different fact from zero and must not render as free.
+   */
+  tokens: CancelEvalRunTokens;
   createdAt: number;
   startedAt: number | null;
   completedAt: number | null;
@@ -495,6 +518,54 @@ export function cancelEvalRunRequestCountsFromJSON(
   );
 }
 
+/** @internal */
+export const CancelEvalRunTokens$inboundSchema: z.ZodType<
+  CancelEvalRunTokens,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  input: z.nullable(z.number().int()),
+  output: z.nullable(z.number().int()),
+  cached: z.nullable(z.number().int()),
+  reasoning: z.nullable(z.number().int()),
+});
+/** @internal */
+export type CancelEvalRunTokens$Outbound = {
+  input: number | null;
+  output: number | null;
+  cached: number | null;
+  reasoning: number | null;
+};
+
+/** @internal */
+export const CancelEvalRunTokens$outboundSchema: z.ZodType<
+  CancelEvalRunTokens$Outbound,
+  z.ZodTypeDef,
+  CancelEvalRunTokens
+> = z.object({
+  input: z.nullable(z.number().int()),
+  output: z.nullable(z.number().int()),
+  cached: z.nullable(z.number().int()),
+  reasoning: z.nullable(z.number().int()),
+});
+
+export function cancelEvalRunTokensToJSON(
+  cancelEvalRunTokens: CancelEvalRunTokens,
+): string {
+  return JSON.stringify(
+    CancelEvalRunTokens$outboundSchema.parse(cancelEvalRunTokens),
+  );
+}
+export function cancelEvalRunTokensFromJSON(
+  jsonString: string,
+): SafeParseResult<CancelEvalRunTokens, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CancelEvalRunTokens$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CancelEvalRunTokens' from JSON`,
+  );
+}
+
 /** @internal */
 export const CancelEvalRunResponseBody$inboundSchema: z.ZodType<
   CancelEvalRunResponseBody,
@@ -523,6 +594,7 @@ export const CancelEvalRunResponseBody$inboundSchema: z.ZodType<
   agent_version: z.nullable(z.string()),
   agent_effort: z.nullable(z.string()),
   cost_usd: z.nullable(z.number()),
+  tokens: z.lazy(() => CancelEvalRunTokens$inboundSchema),
   created_at: z.number().int(),
   started_at: z.nullable(z.number().int()),
   completed_at: z.nullable(z.number().int()),
@@ -575,6 +647,7 @@ export type CancelEvalRunResponseBody$Outbound = {
   agent_version: string | null;
   agent_effort: string | null;
   cost_usd: number | null;
+  tokens: CancelEvalRunTokens$Outbound;
   created_at: number;
   started_at: number | null;
   completed_at: number | null;
@@ -610,6 +683,7 @@ export const CancelEvalRunResponseBody$outboundSchema: z.ZodType<
   agentVersion: z.nullable(z.string()),
   agentEffort: z.nullable(z.string()),
   costUsd: z.nullable(z.number()),
+  tokens: z.lazy(() => CancelEvalRunTokens$outboundSchema),
   createdAt: z.number().int(),
   startedAt: z.nullable(z.number().int()),
   completedAt: z.nullable(z.number().int()),

package/src/models/operations/createevalrun.ts

@@ -83,6 +83,25 @@ export type RequestCounts = {
   failed: number;
 };
 
+/**
+ * Token totals for the run, summed over its samples when it finalized. Each is null when nothing reported that figure, which is a different fact from zero and must not render as free.
+ */
+export type Tokens = {
+  /**
+   * Prompt tokens over the run's samples, `cached` included.
+   */
+  input: number | null;
+  output: number | null;
+  /**
+   * The share of `input` the provider served from its prompt cache. Can exceed `input` on an older harness import, where the two numbers came from different accountings — treat the pair as inconsistent rather than deriving a hit rate from it.
+   */
+  cached: number | null;
+  /**
+   * Reasoning tokens inside `output`, summed over the samples whose provider reported the split. Null when none did; the per-task figures in `metrics.by_task` estimate the split from the stored text in that case.
+   */
+  reasoning: number | null;
+};
+
 /**
  * OK
  */
@@ -127,6 +146,10 @@ export type CreateEvalRunResponseBody = {
    * Total spend for the run in USD. Null when the harness did not report cost.
    */
   costUsd: number | null;
+  /**
+   * Token totals for the run, summed over its samples when it finalized. Each is null when nothing reported that figure, which is a different fact from zero and must not render as free.
+   */
+  tokens: Tokens;
   createdAt: number;
   startedAt: number | null;
   completedAt: number | null;
@@ -465,6 +488,47 @@ export function requestCountsFromJSON(
   );
 }
 
+/** @internal */
+export const Tokens$inboundSchema: z.ZodType<Tokens, z.ZodTypeDef, unknown> = z
+  .object({
+    input: z.nullable(z.number().int()),
+    output: z.nullable(z.number().int()),
+    cached: z.nullable(z.number().int()),
+    reasoning: z.nullable(z.number().int()),
+  });
+/** @internal */
+export type Tokens$Outbound = {
+  input: number | null;
+  output: number | null;
+  cached: number | null;
+  reasoning: number | null;
+};
+
+/** @internal */
+export const Tokens$outboundSchema: z.ZodType<
+  Tokens$Outbound,
+  z.ZodTypeDef,
+  Tokens
+> = z.object({
+  input: z.nullable(z.number().int()),
+  output: z.nullable(z.number().int()),
+  cached: z.nullable(z.number().int()),
+  reasoning: z.nullable(z.number().int()),
+});
+
+export function tokensToJSON(tokens: Tokens): string {
+  return JSON.stringify(Tokens$outboundSchema.parse(tokens));
+}
+export function tokensFromJSON(
+  jsonString: string,
+): SafeParseResult<Tokens, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Tokens$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Tokens' from JSON`,
+  );
+}
+
 /** @internal */
 export const CreateEvalRunResponseBody$inboundSchema: z.ZodType<
   CreateEvalRunResponseBody,
@@ -493,6 +557,7 @@ export const CreateEvalRunResponseBody$inboundSchema: z.ZodType<
   agent_version: z.nullable(z.string()),
   agent_effort: z.nullable(z.string()),
   cost_usd: z.nullable(z.number()),
+  tokens: z.lazy(() => Tokens$inboundSchema),
   created_at: z.number().int(),
   started_at: z.nullable(z.number().int()),
   completed_at: z.nullable(z.number().int()),
@@ -545,6 +610,7 @@ export type CreateEvalRunResponseBody$Outbound = {
   agent_version: string | null;
   agent_effort: string | null;
   cost_usd: number | null;
+  tokens: Tokens$Outbound;
   created_at: number;
   started_at: number | null;
   completed_at: number | null;
@@ -580,6 +646,7 @@ export const CreateEvalRunResponseBody$outboundSchema: z.ZodType<
   agentVersion: z.nullable(z.string()),
   agentEffort: z.nullable(z.string()),
   costUsd: z.nullable(z.number()),
+  tokens: z.lazy(() => Tokens$outboundSchema),
   createdAt: z.number().int(),
   startedAt: z.nullable(z.number().int()),
   completedAt: z.nullable(z.number().int()),