lua-cli 3.32.2 → 3.32.3

package/dist/api-exports.d.ts

@@ -189,6 +189,34 @@ declare interface AgentInvocationInput {
     };
 }
 
+/**
+ * LUA-724 (PR 7) — the billed turn's pricing inputs, exactly as chat's settlement event carries
+ * them (`chat.service.trackLlmInferenceUsage`): the model that ACTUALLY served the turn (the
+ * resolver's code, not the caller's pin), the de-paged `contextInputTokens` (largest single
+ * step's prompt — never the whole-turn sum), the tool-call COUNT, and whether the turn ran on
+ * the org's own key. `chargedCredits` echoes the gate's answer (true ⇒ the legacy pool deducted
+ * in real time; false ⇒ seat org / free turn — settlement meters it).
+ *
+ * Stamped by the serving pod ONLY on internal-auth turns that carry a billing `operationId`
+ * (the workflow agent-step loopback), as the enumerable `luaMeter` top-level field of the
+ * generate envelope — never on a Bearer turn, so the public wire is byte-identical. The
+ * workflow executor prices the step's `run.budget.spent` from it with `priceModelCall`.
+ */
+declare interface AgentInvocationMeter {
+    model?: string;
+    contextInputTokens?: number;
+    /** Tool-call COUNT (`toolNames.length`) — the tier's tool signal. */
+    toolsFired?: number;
+    /**
+     * The tool names fired, one entry per call (repeats kept), exactly as the usage event's
+     * `toolNames` — settlement intersects them with the pricing config's `docProcessingToolNames`
+     * to force the heavy tier (`hasDocProcessingTool`), so the workflow price must see them too.
+     */
+    toolNames?: string[];
+    byok?: boolean;
+    chargedCredits?: boolean;
+}
+
 declare interface AgentInvocationOutput {
     /** Final response text (post-processor-modified, if applicable). */
     text: string;
@@ -211,6 +239,12 @@ declare interface AgentInvocationOutput {
     };
     /** Names of tools invoked during generation. */
     toolsUsed?: string[];
+    /**
+     * LUA-724 (PR 7) — the turn's pricing inputs (see `AgentInvocationMeter`). Present only when
+     * the serving pod stamped `luaMeter` (an `operationId`-bearing internal-auth turn); absent
+     * otherwise — legacy outputs are byte-identical.
+     */
+    meter?: AgentInvocationMeter;
     /** Trusted effects emitted by Lua-owned tool wrappers. This is intentionally
      *  a small aggregate, not raw tool output: unattended task receipts use it
      *  to report what happened without trusting model-authored prose. */
@@ -919,11 +953,14 @@ declare interface BuiltWorkflow {
     }>;
 }
 
-/** R11 — `CancelRunVerdict` (PRO-979 vocabulary). */
+/** R11 — `CancelRunVerdict` (PRO-979 vocabulary; §9.5.2 — a terminal run answers `state:'terminal'`, never an error). */
 declare interface CancelRunVerdict {
     status: WorkflowRunStatus;
     nextAction: string;
     forceAvailableAt?: string;
+    cancelRequested?: boolean;
+    state?: 'running' | 'cancellation_requested' | 'abandoned' | 'terminal';
+    transitioned?: boolean;
 }
 
 /**
@@ -5031,13 +5068,17 @@ export declare interface LuaWorkflowConfig {
      * `maxDurationSeconds` default 604 800; 2 592 000 when the graph contains an approval / waitForSignal / suspend-capable
      * step (P1-4). The three members the SDK forwards, spelled by the ONE definition budget (`WorkflowDefinitionBudget`).
      *
-     * `maxCredits` counts agent steps, never tokens (LUA-708): an inline agent step settles a flat 1 credit when it
-     * completes, a `tier:'job'` attempt a flat 4 at its first claim (a retry is a new attempt). The run parks on a
-     * budget gate (`nextAction:'raise_budget'`, `lua workflows raise-budget`) when what remains is under the next agent
-     * step's reserve — so `maxCredits: 40` buys ten Job-tier attempts, and a value under 4 never dispatches one. Each
-     * attempt then runs to its own wall (`timeoutSeconds`), `maxInputTokens` (default 4M ≈ $1–13 on a Sonnet-class
-     * model), `maxMessages` and `maxTurns`; nothing meters its tokens against the credits mid-attempt. Size
-     * `maxInputTokens` for what one attempt may cost and `maxCredits` for how many attempts the run may make.
+     * `maxCredits` never meters tokens (LUA-708). Flat metering (every run while `LUA_WORKFLOWS_METERING_V2` is off):
+     * an inline agent step settles a flat 1 credit when it completes, a `tier:'job'` attempt a flat 4 at its first
+     * claim (a retry is a new attempt) — so `maxCredits: 40` buys ten Job-tier attempts, and a value under 4 never
+     * dispatches one. Priced metering (LUA-724, the flag on): an inline agent step settles what chat charged for the
+     * turn — one credit per model call on the legacy plan, `tier × model multiplier` actions on a seat plan (then the
+     * cap is compared in actions) — and `lua workflows status` says which mode a run used (`usage.metering`). Either
+     * way the run parks on a budget gate (`nextAction:'raise_budget'`, `lua workflows raise-budget`) when what remains
+     * is under the next agent step's reserve. Each Job-tier attempt then runs to its own wall (`timeoutSeconds`),
+     * `maxInputTokens` (default 4M ≈ $1–13 on a Sonnet-class model), `maxMessages` and `maxTurns`; nothing meters its
+     * tokens against the credits mid-attempt. Size `maxInputTokens` for what one attempt may cost and `maxCredits`
+     * for how many attempts the run may make.
      */
     budget?: Pick<WorkflowDefinitionBudget, 'maxCredits' | 'maxSteps' | 'maxDurationSeconds'>;
     /** verbatim LuaJob union (D12) → Job{kind:'workflow'} on publish */
@@ -7315,6 +7356,39 @@ declare interface WorkflowRun {
     outputPreview?: string;
     /** LUA-643: every shape says whether a result exists; `--steps` (`fields:'full'`) serves it. */
     hasOutput?: boolean;
+    /**
+     * §08 §8.1 `usage` — the settled spend and, LUA-724 (PR 8), how it was metered: `metering` `'flat'` (1 credit per
+     * inline agent step, 4 per Job-tier attempt — every run while `LUA_WORKFLOWS_METERING_V2` is off) or `'priced'`
+     * (charged like chat: a credit per model call on the legacy plan, `tier × model multiplier` actions on a seat
+     * plan — then `engine` names the plan and `actionsUsed` carries a seat run's actions).
+     */
+    usage?: {
+        creditsUsed?: number;
+        actionsEstimate?: number;
+        actionsUsed?: number;
+        metering?: 'flat' | 'priced';
+        engine?: 'legacy' | 'seat';
+        steps?: number;
+        inputTokens?: number;
+        outputTokens?: number;
+    };
+    /**
+     * R4: the run's caps and settled spend. `maxCredits` and `remaining` are both absent on an uncapped run (`0` = unset);
+     * `remaining` is the engine's pre-dispatch subtraction (priced actions and claimed-step holds count), floored at 0.
+     */
+    budget?: {
+        maxCredits?: number;
+        maxSteps?: number;
+        maxDurationSeconds?: number;
+        unit?: 'credits' | 'actions';
+        spent?: {
+            credits?: number;
+            actionsEstimate?: number;
+            steps?: number;
+        };
+        reserved?: number;
+        remaining?: number;
+    };
     createdAt: string;
     startedAt?: string;
     completedAt?: string;