@wardby/cli 0.5.1 → 0.5.2

package/dist/core/engine-native.js

@@ -307,7 +307,9 @@ export class NativeEngine {
                 error: "LLM stream ended without a usage summary.",
             };
         }
-        const calibration = checkTokenCalibration(inputTokens, usage.inputTokens);
+        // The estimate covers the whole prompt; LlmUsage.inputTokens excludes
+        // cache-write tokens (billed separately), so add them back to compare.
+        const calibration = checkTokenCalibration(inputTokens, usage.inputTokens + (usage.cacheWriteTokens ?? 0));
         if (calibration.diverged) {
             const direction = calibration.deltaRatio < 0
                 ? "UNDERestimated (dangerous — the pre-flight refuse/gate could admit an over-budget run)"

package/dist/help-index.json

@@ -1185,8 +1185,8 @@
       ],
       "appliesTo": "\">=0.4.0\"",
       "sourcePath": "models.md",
-      "markdown": "\n# Models and pricing\n\nWardby prices and routes every model call from one catalog: the models this\nrelease ships, overlaid with this deployment's own additions and overrides.\nAn agent can use a model only when it's in the catalog and its provider has\ncredentials configured here.\n\n## The five tools\n\n| Tool            | Scope          | What it does                                                                              |\n| --------------- | -------------- | ----------------------------------------------------------------------------------------- |\n| `list_models`   | `agents:read`  | Every active catalog entry (or, with `includeDisabled: true`, disabled ones too).         |\n| `get_model`     | `agents:read`  | One entry by `modelId`; for an override, also the shipped entry it shadows.               |\n| `set_model`     | `models:admin` | Adds or completely replaces one entry. Every field is required.                           |\n| `disable_model` | `models:admin` | Removes a model from routing without deleting its pricing history.                        |\n| `reset_model`   | `models:admin` | Removes every row for a model id, reverting to the shipped entry (if any) or removing it. |\n\nReading the catalog needs only `agents:read` — no secrets live in an entry.\nChanging it needs `models:admin`, honored only for a caller whose Wardby role\ngrants it: `admin`, or the narrower `model-manager` role.\n\nAn entry's `origin` is `shipped` or `override`; `routable` says whether this\ndeployment can actually route to it right now; `shippedDiffers` (overrides of\na shipped model only) says whether your override has drifted from the\ncurrent shipped values. See [`docs/models.md`](../docs/models.md) for the\nfull field reference.\n\n## Adding or overriding a model\n\n```json\n{\n  \"provider\": \"anthropic\",\n  \"modelId\": \"claude-example-model\",\n  \"encoding\": \"o200k_base\",\n  \"inputPerMTok\": 0.0,\n  \"outputPerMTok\": 0.0,\n  \"cachedInputPerMTok\": 0.0,\n  \"cacheWritePerMTok\": 0.0,\n  \"efforts\": [\"low\", \"medium\", \"high\"],\n  \"thinkingMode\": \"adaptive\",\n  \"sourceUrl\": \"https://example.com/replace-with-the-providers-own-pricing-page\"\n}\n```\n\nThe rates above are placeholders. Copy the provider's own published rates for\nthat exact model — including its cache read and cache write rates — from its\npricing page, and point `sourceUrl` at that page; never compute cache rates\nfrom `inputPerMTok` with a multiplier.\n\n`set_model` refuses (409) a `modelId` another provider already owns. A\nshipped id always belongs to its shipped provider — permanently; no other\nprovider can ever claim it, not even by disabling or resetting the override.\nA non-shipped id already claimed by another provider (its row active or\ndisabled) is freed only by `reset_model` — it takes only the `modelId` and\nclears every row for it, whichever provider owns it; `disable_model` alone\nnever frees it, since the disabled row still reserves the id.\n\n`thinkingMode` (`adaptive`, `manual`, or `none`) must match what the exact\nmodel accepts. Getting it wrong doesn't fail at `set_model` — it fails later,\nwhen a run calls the model, with `unsupported_anthropic_feature`.\nFor Claude Code coding runs, `efforts` is also the exact set of levels a run\nmay send, so always include the model's default effort level.\n\nA newly released Claude model may also need a newer Claude Code than your\nClaude Code worker image has: coding runs on it then fail as\n`provider_rejected` (no cost) while native runs work. Upgrade wardby and\nrebuild the worker images before using the model in Claude Code agents.\n\nCatalog changes take effect on the writing process immediately, and on every\nother wardby process within `WARDBY_MODEL_CATALOG_REFRESH_SECONDS` (default\n45). A run already in progress keeps the catalog entry it started with, so\ndisabling or repricing a model never changes a run already under way — only\nnew runs.\n\nIf this deployment delegates to an identity provider, define `models:admin`\nthere before relying on it, and map the `model-manager` role (or `admin`) to\nthe people who maintain pricing — see\n[Configure identity and privileged access](identity-and-access.md).\n\nIf a run can't use a model, see\n[Model not available](errors/model-unavailable.md).\n",
-      "plainText": "Models and pricing Wardby prices and routes every model call from one catalog: the models this release ships, overlaid with this deployment's own additions and overrides. An agent can use a model only when it's in the catalog and its provider has credentials configured here. The five tools | Tool | Scope | What it does | | --------------- | -------------- | ----------------------------------------------------------------------------------------- | | listmodels | agents:read | Every active catalog entry (or, with includeDisabled: true, disabled ones too). | | getmodel | agents:read | One entry by modelId; for an override, also the shipped entry it shadows. | | setmodel | models:admin | Adds or completely replaces one entry. Every field is required. | | disablemodel | models:admin | Removes a model from routing without deleting its pricing history. | | resetmodel | models:admin | Removes every row for a model id, reverting to the shipped entry (if any) or removing it. | Reading the catalog needs only agents:read — no secrets live in an entry. Changing it needs models:admin, honored only for a caller whose Wardby role grants it: admin, or the narrower model-manager role. An entry's origin is shipped or override; routable says whether this deployment can actually route to it right now; shippedDiffers (overrides of a shipped model only) says whether your override has drifted from the current shipped values. See docs/models.md for the full field reference. Adding or overriding a model { \"provider\": \"anthropic\", \"modelId\": \"claude-example-model\", \"encoding\": \"o200kbase\", \"inputPerMTok\": 0.0, \"outputPerMTok\": 0.0, \"cachedInputPerMTok\": 0.0, \"cacheWritePerMTok\": 0.0, \"efforts\": [\"low\", \"medium\", \"high\"], \"thinkingMode\": \"adaptive\", \"sourceUrl\": \"https://example.com/replace-with-the-providers-own-pricing-page\" } The rates above are placeholders. Copy the provider's own published rates for that exact model — including its cache read and cache write rates — from its pricing page, and point sourceUrl at that page; never compute cache rates from inputPerMTok with a multiplier. setmodel refuses (409) a modelId another provider already owns. A shipped id always belongs to its shipped provider — permanently; no other provider can ever claim it, not even by disabling or resetting the override. A non-shipped id already claimed by another provider (its row active or disabled) is freed only by resetmodel — it takes only the modelId and clears every row for it, whichever provider owns it; disablemodel alone never frees it, since the disabled row still reserves the id. thinkingMode (adaptive, manual, or none) must match what the exact model accepts. Getting it wrong doesn't fail at setmodel — it fails later, when a run calls the model, with unsupportedanthropicfeature. For Claude Code coding runs, efforts is also the exact set of levels a run may send, so always include the model's default effort level. A newly released Claude model may also need a newer Claude Code than your Claude Code worker image has: coding runs on it then fail as providerrejected (no cost) while native runs work. Upgrade wardby and rebuild the worker images before using the model in Claude Code agents. Catalog changes take effect on the writing process immediately, and on every other wardby process within WARDBYMODELCATALOGREFRESHSECONDS (default 45). A run already in progress keeps the catalog entry it started with, so disabling or repricing a model never changes a run already under way — only new runs. If this deployment delegates to an identity provider, define models:admin there before relying on it, and map the model-manager role (or admin) to the people who maintain pricing — see Configure identity and privileged access. If a run can't use a model, see Model not available.",
+      "markdown": "\n# Models and pricing\n\nWardby prices and routes every model call from one catalog: the models this\nrelease ships, overlaid with this deployment's own additions and overrides.\nAn agent can use a model only when it's in the catalog and its provider has\ncredentials configured here.\n\n## The five tools\n\n| Tool            | Scope          | What it does                                                                              |\n| --------------- | -------------- | ----------------------------------------------------------------------------------------- |\n| `list_models`   | `agents:read`  | Every active catalog entry (or, with `includeDisabled: true`, disabled ones too).         |\n| `get_model`     | `agents:read`  | One entry by `modelId`; for an override, also the shipped entry it shadows.               |\n| `set_model`     | `models:admin` | Adds or completely replaces one entry. Every field is required.                           |\n| `disable_model` | `models:admin` | Removes a model from routing without deleting its pricing history.                        |\n| `reset_model`   | `models:admin` | Removes every row for a model id, reverting to the shipped entry (if any) or removing it. |\n\nReading the catalog needs only `agents:read` — no secrets live in an entry.\nChanging it needs `models:admin`, honored only for a caller whose Wardby role\ngrants it: `admin`, or the narrower `model-manager` role.\n\nAn entry's `origin` is `shipped` or `override`; `routable` says whether this\ndeployment can actually route to it right now; `shippedDiffers` (overrides of\na shipped model only) says whether your override has drifted from the\ncurrent shipped values. See [`docs/models.md`](../docs/models.md) for the\nfull field reference.\n\n## Adding or overriding a model\n\n```json\n{\n  \"provider\": \"anthropic\",\n  \"modelId\": \"claude-example-model\",\n  \"encoding\": \"o200k_base\",\n  \"inputPerMTok\": 0.0,\n  \"outputPerMTok\": 0.0,\n  \"cachedInputPerMTok\": 0.0,\n  \"cacheWritePerMTok\": 0.0,\n  \"efforts\": [\"low\", \"medium\", \"high\"],\n  \"thinkingMode\": \"adaptive\",\n  \"sourceUrl\": \"https://example.com/replace-with-the-providers-own-pricing-page\"\n}\n```\n\nThe rates above are placeholders. Copy the provider's own published rates for\nthat exact model — including its cache read and cache write rates — from its\npricing page, and point `sourceUrl` at that page; never compute cache rates\nfrom `inputPerMTok` with a multiplier.\n\n`set_model` refuses (409) a `modelId` another provider already owns. A\nshipped id always belongs to its shipped provider — permanently; no other\nprovider can ever claim it, not even by disabling or resetting the override.\nA non-shipped id already claimed by another provider (its row active or\ndisabled) is freed only by `reset_model` — it takes only the `modelId` and\nclears every row for it, whichever provider owns it; `disable_model` alone\nnever frees it, since the disabled row still reserves the id.\n\n`thinkingMode` (`adaptive`, `manual`, or `none`) must match what the exact\nmodel accepts. Getting it wrong doesn't fail at `set_model` — it fails later,\nwhen a run calls the model, with `unsupported_anthropic_feature`.\nFor Claude Code coding runs, `efforts` is also the exact set of levels a run\nmay send, so always include the model's default effort level.\n\nOpenAI models keep `thinkingMode` `none`; `efforts` alone drives\n`reasoning.effort` on native agents, which call OpenAI's Responses API\n(`store: false`). `gpt-5.6-sol`/`terra`/`luna` and `gpt-6-astra` list `low`\nthrough `max`; `gpt-4o`, `gpt-4o-mini` and the `gpt-4.1` family list none.\nReasoning models reject sampling parameters such as `temperature`; wardby\ndoesn't send them. Reasoning tokens bill as output tokens, charged when the\ncall ends, so one call can take a run past its budget by its reasoning; higher\neffort raises that ceiling.\n\nAfter an upgrade, a `set_model` override of a shipped model keeps its stored\n`efforts` (it replaces the shipped entry wholesale). If those are empty,\n`create_agent`/`update_agent` reject an `effort` for the model: run\n`reset_model`, or `set_model` again with the new efforts, to pick up shipped\nchanges.\n\nA newly released Claude model may also need a newer Claude Code than your\nClaude Code worker image has: coding runs on it then fail as\n`provider_rejected` (no cost) while native runs work. Upgrade wardby and\nrebuild the worker images before using the model in Claude Code agents.\n\nCatalog changes take effect on the writing process immediately, and on every\nother wardby process within `WARDBY_MODEL_CATALOG_REFRESH_SECONDS` (default\n45). A run already in progress keeps the catalog entry it started with, so\ndisabling or repricing a model never changes a run already under way — only\nnew runs.\n\nIf this deployment delegates to an identity provider, define `models:admin`\nthere before relying on it, and map the `model-manager` role (or `admin`) to\nthe people who maintain pricing — see\n[Configure identity and privileged access](identity-and-access.md).\n\nIf a run can't use a model, see\n[Model not available](errors/model-unavailable.md).\n",
+      "plainText": "Models and pricing Wardby prices and routes every model call from one catalog: the models this release ships, overlaid with this deployment's own additions and overrides. An agent can use a model only when it's in the catalog and its provider has credentials configured here. The five tools | Tool | Scope | What it does | | --------------- | -------------- | ----------------------------------------------------------------------------------------- | | listmodels | agents:read | Every active catalog entry (or, with includeDisabled: true, disabled ones too). | | getmodel | agents:read | One entry by modelId; for an override, also the shipped entry it shadows. | | setmodel | models:admin | Adds or completely replaces one entry. Every field is required. | | disablemodel | models:admin | Removes a model from routing without deleting its pricing history. | | resetmodel | models:admin | Removes every row for a model id, reverting to the shipped entry (if any) or removing it. | Reading the catalog needs only agents:read — no secrets live in an entry. Changing it needs models:admin, honored only for a caller whose Wardby role grants it: admin, or the narrower model-manager role. An entry's origin is shipped or override; routable says whether this deployment can actually route to it right now; shippedDiffers (overrides of a shipped model only) says whether your override has drifted from the current shipped values. See docs/models.md for the full field reference. Adding or overriding a model { \"provider\": \"anthropic\", \"modelId\": \"claude-example-model\", \"encoding\": \"o200kbase\", \"inputPerMTok\": 0.0, \"outputPerMTok\": 0.0, \"cachedInputPerMTok\": 0.0, \"cacheWritePerMTok\": 0.0, \"efforts\": [\"low\", \"medium\", \"high\"], \"thinkingMode\": \"adaptive\", \"sourceUrl\": \"https://example.com/replace-with-the-providers-own-pricing-page\" } The rates above are placeholders. Copy the provider's own published rates for that exact model — including its cache read and cache write rates — from its pricing page, and point sourceUrl at that page; never compute cache rates from inputPerMTok with a multiplier. setmodel refuses (409) a modelId another provider already owns. A shipped id always belongs to its shipped provider — permanently; no other provider can ever claim it, not even by disabling or resetting the override. A non-shipped id already claimed by another provider (its row active or disabled) is freed only by resetmodel — it takes only the modelId and clears every row for it, whichever provider owns it; disablemodel alone never frees it, since the disabled row still reserves the id. thinkingMode (adaptive, manual, or none) must match what the exact model accepts. Getting it wrong doesn't fail at setmodel — it fails later, when a run calls the model, with unsupportedanthropicfeature. For Claude Code coding runs, efforts is also the exact set of levels a run may send, so always include the model's default effort level. OpenAI models keep thinkingMode none; efforts alone drives reasoning.effort on native agents, which call OpenAI's Responses API (store: false). gpt-5.6-sol/terra/luna and gpt-6-astra list low through max; gpt-4o, gpt-4o-mini and the gpt-4.1 family list none. Reasoning models reject sampling parameters such as temperature; wardby doesn't send them. Reasoning tokens bill as output tokens, charged when the call ends, so one call can take a run past its budget by its reasoning; higher effort raises that ceiling. After an upgrade, a setmodel override of a shipped model keeps its stored efforts (it replaces the shipped entry wholesale). If those are empty, createagent/updateagent reject an effort for the model: run resetmodel, or setmodel again with the new efforts, to pick up shipped changes. A newly released Claude model may also need a newer Claude Code than your Claude Code worker image has: coding runs on it then fail as providerrejected (no cost) while native runs work. Upgrade wardby and rebuild the worker images before using the model in Claude Code agents. Catalog changes take effect on the writing process immediately, and on every other wardby process within WARDBYMODELCATALOGREFRESHSECONDS (default 45). A run already in progress keeps the catalog entry it started with, so disabling or repricing a model never changes a run already under way — only new runs. If this deployment delegates to an identity provider, define models:admin there before relying on it, and map the model-manager role (or admin) to the people who maintain pricing — see Configure identity and privileged access. If a run can't use a model, see Model not available.",
       "headings": [
         {
           "level": 1,

package/dist/providers/llm/catalog-shipped.d.ts

@@ -14,5 +14,5 @@
  * literally.
  */
 import type { CatalogEntry } from "./catalog-types.js";
-export declare const SHIPPED_CATALOG_VERSION = "2026-10-03";
+export declare const SHIPPED_CATALOG_VERSION = "2026-10-08";
 export declare const SHIPPED_CATALOG: readonly CatalogEntry[];

package/dist/providers/llm/catalog-shipped.js

@@ -1,4 +1,4 @@
-export const SHIPPED_CATALOG_VERSION = "2026-10-03";
+export const SHIPPED_CATALOG_VERSION = "2026-10-08";
 const ALL_EFFORTS = ["low", "medium", "high", "xhigh", "max"];
 export const SHIPPED_CATALOG = [
     // OpenAI
@@ -65,7 +65,7 @@ export const SHIPPED_CATALOG = [
         outputPerMTok: 50.0,
         cachedInputPerMTok: 1.0,
         cacheWritePerMTok: 12.5,
-        efforts: [],
+        efforts: ALL_EFFORTS,
         thinkingMode: "none",
     },
     {
@@ -76,7 +76,7 @@ export const SHIPPED_CATALOG = [
         outputPerMTok: 20.0,
         cachedInputPerMTok: 0.4,
         cacheWritePerMTok: 5.0,
-        efforts: [],
+        efforts: ALL_EFFORTS,
         thinkingMode: "none",
     },
     {
@@ -87,7 +87,7 @@ export const SHIPPED_CATALOG = [
         outputPerMTok: 12.0,
         cachedInputPerMTok: 0.2,
         cacheWritePerMTok: 2.5,
-        efforts: [],
+        efforts: ALL_EFFORTS,
         thinkingMode: "none",
     },
     {
@@ -98,7 +98,7 @@ export const SHIPPED_CATALOG = [
         outputPerMTok: 1.2,
         cachedInputPerMTok: 0.02,
         cacheWritePerMTok: 0.25,
-        efforts: [],
+        efforts: ALL_EFFORTS,
         thinkingMode: "none",
     },
     // Anthropic (direct API)

package/dist/providers/llm/openai.d.ts

@@ -1,7 +1,30 @@
 /**
- * OpenAI adapter for the `LlmProvider` seam — Phase 1's only concrete LLM
- * adapter. The `openai` npm package is used only inside this file; core
- * never imports it.
+ * OpenAI adapter for the `LlmProvider` seam. The `openai` npm package is used
+ * only inside this file; core never imports it.
+ *
+ * It speaks the Responses API, not Chat Completions: Chat Completions rejects
+ * any request carrying tools on gpt-5.6-* and gpt-6-*, while Responses takes
+ * tools on every OpenAI model and reasoning effort on the reasoning ones.
+ *
+ * Mapping notes (what the Responses API cannot carry, and why that's fine):
+ * - `stopSequences` is dropped — Responses has no stop parameter ("Unknown
+ *   parameter" on every model). No caller sets it today.
+ * - `LlmMessage.name` is dropped — Responses has no per-message name. The
+ *   engine sets it only on tool results, where `call_id` already correlates.
+ * - `store: false` is always sent — Responses stores every response by
+ *   default, and wardby replays the whole conversation itself each turn.
+ * - Reasoning items are not replayed between turns: with `store: false` the
+ *   next turn starts without the previous turn's hidden reasoning, only the
+ *   visible text and function_call/function_call_output items. That costs
+ *   some reasoning continuity, not correctness.
+ * - Reasoning tokens never stream as deltas, so the engine's mid-stream budget
+ *   cap (driven by text deltas) can't see them. They arrive inside
+ *   `output_tokens` on the final usage and are charged when the call ends, at
+ *   the output rate, which is how OpenAI bills them. There is no per-call
+ *   reservation: one call can take a run past its budget by that call's
+ *   reasoning, and higher effort levels raise that ceiling. The pre-turn
+ *   input-estimate gate and the run-level budget-group reservation still
+ *   apply.
  */
 import OpenAI from "openai";
 import type { LlmMessage, LlmRequest, LlmStreamEvent, LlmToolDef } from "./types.js";
@@ -22,6 +45,14 @@ export declare class OpenAiLlmProvider implements CatalogLlmAdapter {
     constructor(apiKey?: string, client?: OpenAI, lookup?: CatalogLookup);
     withEntry(entry: CatalogEntry): OpenAiLlmProvider;
     stream(req: LlmRequest, signal?: AbortSignal): AsyncIterable<LlmStreamEvent>;
+    /**
+     * OpenAI reports both `cached_tokens` and `cache_write_tokens` as subsets
+     * of `input_tokens`. wardby's LlmUsage convention (claude-messages.ts,
+     * computeCost) is that `inputTokens` includes cache reads but NOT cache
+     * writes, which are billed separately at the write rate — so the writes
+     * come out of `inputTokens` here, or computeCost would charge them twice.
+     */
+    private toUsage;
     countTokens(model: string, messages: LlmMessage[], tools?: LlmToolDef[]): Promise<number>;
     priceUsd(model: string, usage: {
         inputTokens: number;

package/dist/providers/llm/openai.js

@@ -1,7 +1,30 @@
 /**
- * OpenAI adapter for the `LlmProvider` seam — Phase 1's only concrete LLM
- * adapter. The `openai` npm package is used only inside this file; core
- * never imports it.
+ * OpenAI adapter for the `LlmProvider` seam. The `openai` npm package is used
+ * only inside this file; core never imports it.
+ *
+ * It speaks the Responses API, not Chat Completions: Chat Completions rejects
+ * any request carrying tools on gpt-5.6-* and gpt-6-*, while Responses takes
+ * tools on every OpenAI model and reasoning effort on the reasoning ones.
+ *
+ * Mapping notes (what the Responses API cannot carry, and why that's fine):
+ * - `stopSequences` is dropped — Responses has no stop parameter ("Unknown
+ *   parameter" on every model). No caller sets it today.
+ * - `LlmMessage.name` is dropped — Responses has no per-message name. The
+ *   engine sets it only on tool results, where `call_id` already correlates.
+ * - `store: false` is always sent — Responses stores every response by
+ *   default, and wardby replays the whole conversation itself each turn.
+ * - Reasoning items are not replayed between turns: with `store: false` the
+ *   next turn starts without the previous turn's hidden reasoning, only the
+ *   visible text and function_call/function_call_output items. That costs
+ *   some reasoning continuity, not correctness.
+ * - Reasoning tokens never stream as deltas, so the engine's mid-stream budget
+ *   cap (driven by text deltas) can't see them. They arrive inside
+ *   `output_tokens` on the final usage and are charged when the call ends, at
+ *   the output rate, which is how OpenAI bills them. There is no per-call
+ *   reservation: one call can take a run past its budget by that call's
+ *   reasoning, and higher effort levels raise that ceiling. The pre-turn
+ *   input-estimate gate and the run-level budget-group reservation still
+ *   apply.
  */
 import OpenAI from "openai";
 import { encode as encodeCl100kBase } from "gpt-tokenizer/encoding/cl100k_base";
@@ -29,13 +52,46 @@ function encodeForModel(model, text, lookup) {
     const { encoding } = lookup(model);
     return encoding === "o200k_base" ? encodeO200kBase(text) : encodeCl100kBase(text);
 }
-/** Same shape sent to the API in `stream()` — kept as one function so the estimate can never drift from what's actually serialized. */
+/**
+ * Same shape sent to the API in `stream()` — kept as one function so the
+ * estimate can never drift from what's actually serialized. `strict: false`
+ * because wardby's tool schemas aren't written to strict mode's rules (every
+ * property required, additionalProperties false), and Responses defaults
+ * strict on.
+ */
 function toOpenAiTools(tools) {
     return tools.map((t) => ({
         type: "function",
-        function: { name: t.name, description: t.description, parameters: t.parameters },
+        name: t.name,
+        description: t.description,
+        parameters: t.parameters,
+        strict: false,
     }));
 }
+// Responses rejects max_output_tokens below 16 with a 400 ("Expected a value
+// >= 16"). Raising a smaller cap to 16 costs at most a few output tokens;
+// failing the call outright would cost the whole turn.
+const MIN_MAX_OUTPUT_TOKENS = 16;
+/** One `LlmMessage` becomes zero or more Responses input items, in order. */
+function toResponsesInput(messages) {
+    const input = [];
+    for (const m of messages) {
+        if (m.role === "tool") {
+            input.push({ type: "function_call_output", call_id: m.toolCallId ?? "", output: m.content });
+            continue;
+        }
+        const toolCalls = m.role === "assistant" ? (m.toolCalls ?? []) : [];
+        // An assistant turn that only made tool calls has empty text; an empty
+        // assistant message item adds nothing, so omit it.
+        if (!(m.content === "" && toolCalls.length > 0)) {
+            input.push({ role: m.role, content: m.content });
+        }
+        for (const tc of toolCalls) {
+            input.push({ type: "function_call", call_id: tc.id, name: tc.name, arguments: tc.argsJson });
+        }
+    }
+    return input;
+}
 // Fixed: this used to count message tokens only. When a request carries
 // `tools`, OpenAI also tokenizes the serialized tool JSON schemas into the
 // prompt — measured live at a 44-52% under-count for a small tool roster,
@@ -83,80 +139,83 @@ export class OpenAiLlmProvider {
         return new OpenAiLlmProvider("", this.client, pinnedLookup(entry));
     }
     async *stream(req, signal) {
-        const stream = await this.client.chat.completions.create({
+        const entry = this.lookup(req.model);
+        // Effort is sent only at a level the catalog says the model accepts and
+        // dropped otherwise (the LlmRequest.effort contract). Temperature only
+        // goes to non-reasoning models: reasoning models reject it ("not
+        // supported with this model").
+        const sendEffort = req.effort !== undefined && entry.efforts.includes(req.effort);
+        const sendTemperature = req.temperature !== undefined && entry.efforts.length === 0;
+        const params = {
             model: req.model,
-            messages: req.messages.map((m) => ({
-                role: m.role,
-                content: m.content,
-                ...(m.name ? { name: m.name } : {}),
-                ...(m.toolCallId ? { tool_call_id: m.toolCallId } : {}),
-                ...(m.toolCalls && m.toolCalls.length > 0
-                    ? {
-                        tool_calls: m.toolCalls.map((tc) => ({
-                            id: tc.id,
-                            type: "function",
-                            function: { name: tc.name, arguments: tc.argsJson },
-                        })),
-                    }
-                    : {}),
-            })),
-            tools: req.tools ? toOpenAiTools(req.tools) : undefined,
-            max_tokens: req.maxTokens,
-            temperature: req.temperature,
-            stop: req.stopSequences,
+            input: toResponsesInput(req.messages),
             stream: true,
-            stream_options: { include_usage: true },
-        }, { signal });
-        let stopReason = "stop";
-        // OpenAI streams tool-call arguments fragmented across chunks, keyed by
-        // index — buffer per index until the turn's finish_reason confirms the
-        // call is complete, then emit one `tool_call` event per call.
-        const toolCallBuffers = new Map();
-        for await (const chunk of stream) {
-            const choice = chunk.choices[0];
-            if (choice?.delta?.content) {
-                yield { type: "text", delta: choice.delta.content };
-            }
-            if (choice?.delta?.tool_calls) {
-                for (const fragment of choice.delta.tool_calls) {
-                    const buffered = toolCallBuffers.get(fragment.index) ?? { id: "", name: "", argsJson: "" };
-                    if (fragment.id)
-                        buffered.id = fragment.id;
-                    if (fragment.function?.name)
-                        buffered.name += fragment.function.name;
-                    if (fragment.function?.arguments)
-                        buffered.argsJson += fragment.function.arguments;
-                    toolCallBuffers.set(fragment.index, buffered);
-                }
-            }
-            if (choice?.finish_reason) {
-                stopReason = choice.finish_reason;
-                if (stopReason === "tool_calls") {
-                    for (const toolCall of toolCallBuffers.values()) {
-                        yield { type: "tool_call", id: toolCall.id, name: toolCall.name, argsJson: toolCall.argsJson };
+            store: false,
+            ...(req.tools ? { tools: toOpenAiTools(req.tools) } : {}),
+            ...(req.maxTokens !== undefined ? { max_output_tokens: Math.max(req.maxTokens, MIN_MAX_OUTPUT_TOKENS) } : {}),
+            // The SDK's ReasoningEffort type predates xhigh/max; the API accepts them.
+            ...(sendEffort ? { reasoning: { effort: req.effort } } : {}),
+            ...(sendTemperature ? { temperature: req.temperature } : {}),
+        };
+        const stream = await this.client.responses.create(params, { signal });
+        let sawToolCall = false;
+        for await (const event of stream) {
+            switch (event.type) {
+                case "response.output_text.delta":
+                    yield { type: "text", delta: event.delta };
+                    break;
+                case "response.output_item.done":
+                    // Arguments also stream as function_call_arguments.delta fragments,
+                    // but the done item carries the complete call — emit from that.
+                    // An "incomplete" item was cut off (e.g. by max_output_tokens) and
+                    // its arguments are truncated JSON, so it is not a call to run.
+                    if (event.item.type === "function_call" && event.item.status !== "incomplete") {
+                        sawToolCall = true;
+                        yield { type: "tool_call", id: event.item.call_id, name: event.item.name, argsJson: event.item.arguments };
                     }
-                    toolCallBuffers.clear();
+                    break;
+                case "response.completed":
+                case "response.incomplete": {
+                    const stopReason = sawToolCall
+                        ? "tool_calls"
+                        : event.response.incomplete_details?.reason === "max_output_tokens"
+                            ? "length"
+                            : "stop";
+                    yield { type: "done", stopReason, usage: this.toUsage(req.model, event.response.usage) };
+                    break;
                 }
-            }
-            if (chunk.usage) {
-                // OpenAI's prompt caching is automatic and read-only — no billed
-                // "cache write" step, so cacheWriteTokens stays unset here. Other
-                // future adapters (e.g. Bedrock/Claude) may report and bill one.
-                const cachedInputTokens = chunk.usage.prompt_tokens_details?.cached_tokens ?? 0;
-                const usage = {
-                    inputTokens: chunk.usage.prompt_tokens,
-                    outputTokens: chunk.usage.completion_tokens,
-                    cachedInputTokens,
-                    costUsd: this.priceUsd(req.model, {
-                        inputTokens: chunk.usage.prompt_tokens,
-                        outputTokens: chunk.usage.completion_tokens,
-                        cachedInputTokens,
-                    }),
-                };
-                yield { type: "done", stopReason, usage };
+                case "response.failed":
+                    throw new Error(`OpenAI response failed: ${event.response.error?.message ?? "no error message"}`);
+                case "error":
+                    // The SDK usually throws an APIError when an SSE error arrives,
+                    // before yielding it; this branch is a backstop.
+                    throw new Error(`OpenAI stream error: ${event.message}`);
+                default:
+                    break;
             }
         }
     }
+    /**
+     * OpenAI reports both `cached_tokens` and `cache_write_tokens` as subsets
+     * of `input_tokens`. wardby's LlmUsage convention (claude-messages.ts,
+     * computeCost) is that `inputTokens` includes cache reads but NOT cache
+     * writes, which are billed separately at the write rate — so the writes
+     * come out of `inputTokens` here, or computeCost would charge them twice.
+     */
+    toUsage(model, raw) {
+        const cachedInputTokens = raw?.input_tokens_details?.cached_tokens ?? 0;
+        const cacheWriteTokens = raw?.input_tokens_details?.cache_write_tokens ?? 0;
+        const inputTokens = Math.max((raw?.input_tokens ?? 0) - cacheWriteTokens, 0);
+        // output_tokens already includes reasoning tokens.
+        const outputTokens = raw?.output_tokens ?? 0;
+        const tokens = {
+            inputTokens,
+            outputTokens,
+            cachedInputTokens,
+            ...(cacheWriteTokens > 0 ? { cacheWriteTokens } : {}),
+        };
+        return { ...tokens, costUsd: this.priceUsd(model, tokens) };
+    }
     async countTokens(model, messages, tools) {
         return estimateTokens(model, messages, tools, this.lookup);
     }

package/dist/quickstart-images.json

@@ -1 +1 @@
-{"runtime":"ghcr.io/wardby/wardby/wardby-runtime@sha256:1b6646eccf13dbe534257f641b757cd11a127ef54741cf7b7a0a56fc53de60da","worker":"ghcr.io/wardby/wardby/wardby-coding-worker@sha256:0a9d4a8f737b4b2badde4dfad5646db3cb26ead4f3783ee0c13819daf0f44b1a","claudeWorker":"ghcr.io/wardby/wardby/wardby-claude-coding-worker@sha256:36fdf3b28d60a332b170ec5bd52d7158d11cab70562d7cadffe2fa286ccff974","claudeToolRunner":"ghcr.io/wardby/wardby/wardby-claude-tool-runner@sha256:68c276dce5341bf5e8dd3723ae8ad45ae01c81065a99ee2c5ca9847ce1afe0d7"}
+{"runtime":"ghcr.io/wardby/wardby/wardby-runtime@sha256:2747fa03de5b94f03a3cb493888e2a03d9eec59b59e1ac28f55a91c63ed073a9","worker":"ghcr.io/wardby/wardby/wardby-coding-worker@sha256:29908387f38d1307b6050cd322b9abb5576ac7b403a482b8dd8a2dc4fb8eea47","claudeWorker":"ghcr.io/wardby/wardby/wardby-claude-coding-worker@sha256:b8495a54f24a69142d99faf534dc6471526ae999008f5807b1e9bf24d4eab957","claudeToolRunner":"ghcr.io/wardby/wardby/wardby-claude-tool-runner@sha256:cb125592be91ebc660b342a0ecfed6744b9b0626445607737f3deb6a5801faaf"}

package/docs/getting-started.md

@@ -221,9 +221,11 @@ sent on every model call and trades depth of reasoning against latency and
 output-token cost; lower levels are faster and cheaper per turn. Leave it unset
 to use the provider's default. Wardby rejects a level the agent's model does not
 accept, including when you later change the model (clear it with
-`effort: null`). Effort currently applies to direct Anthropic API models that
-support it; OpenAI and Bedrock models accept no effort setting, and coding
-agents do not use it.
+`effort: null`). Effort applies to direct Anthropic API models that support
+it and to the OpenAI reasoning models (`gpt-5.6-sol`, `gpt-5.6-terra`,
+`gpt-5.6-luna`, `gpt-6-astra`), which accept `low` through `max`; the older
+OpenAI models (`gpt-4o`, `gpt-4o-mini`, and the `gpt-4.1` family) and Bedrock
+models accept no effort setting. Coding agents do not use it.
 
 ## Coding agents
 

package/docs/models.md

@@ -130,7 +130,24 @@ and must match what that exact model actually accepts:
 - `manual` — a fixed thinking budget (`{"type": "enabled", "budget_tokens": …}`)
   and no effort level at all. Some smaller Claude models reject `adaptive`
   entirely.
-- `none` — no thinking parameter is sent. Non-Claude models.
+- `none` — no thinking parameter is sent. Non-Claude models, including OpenAI.
+
+OpenAI models always use `none`; their reasoning is controlled by `efforts`
+alone. Native agents call OpenAI's Responses API, and when the agent has an
+`effort` that the model's `efforts` lists, wardby sends it as
+`reasoning.effort`. An empty `efforts` means no reasoning parameter is sent,
+and an agent with no `effort` gets OpenAI's default. The shipped reasoning
+models (`gpt-5.6-sol`, `gpt-5.6-terra`, `gpt-5.6-luna`, `gpt-6-astra`) list
+`low`, `medium`, `high`, `xhigh`, and `max`; the older models (`gpt-4o`,
+`gpt-4o-mini`, the `gpt-4.1` family) list none. OpenAI reasoning models reject
+sampling parameters such as `temperature`; wardby doesn't send them. Requests
+are sent with `store: false`, so OpenAI doesn't store the responses for later
+retrieval. Reasoning tokens are billed as output tokens. They don't stream, so
+a call's reasoning is charged when the call ends, and one call can take a run
+past its budget by that call's reasoning; higher effort levels raise that
+ceiling. The pre-turn input estimate and the budget group's run reservation
+still apply. OpenAI cache-write tokens are billed at the catalog's
+`cacheWritePerMTok`.
 
 Setting the wrong `thinkingMode` (or listing `efforts` a model doesn't
 actually accept) does not fail at `set_model` time — it fails when a coding
@@ -219,3 +236,10 @@ shipped values automatically. `list_models`/`get_model`'s `shippedDiffers`
 field tells you when your override and the current shipped entry disagree,
 so you can decide whether to `reset_model` back to the shipped values or
 leave your override in place.
+
+This matters when a release changes `efforts`: a database override replaces
+the shipped entry wholesale, so an override of an OpenAI reasoning model
+created before the release keeps its stored `efforts` (typically empty).
+While it does, `create_agent` and `update_agent` reject any `effort` for that
+model, and an existing agent's effort is not sent. Run `reset_model` on the id,
+or `set_model` again with the new `efforts`, to pick up the shipped levels.

package/help/models.md

@@ -70,6 +70,21 @@ when a run calls the model, with `unsupported_anthropic_feature`.
 For Claude Code coding runs, `efforts` is also the exact set of levels a run
 may send, so always include the model's default effort level.
 
+OpenAI models keep `thinkingMode` `none`; `efforts` alone drives
+`reasoning.effort` on native agents, which call OpenAI's Responses API
+(`store: false`). `gpt-5.6-sol`/`terra`/`luna` and `gpt-6-astra` list `low`
+through `max`; `gpt-4o`, `gpt-4o-mini` and the `gpt-4.1` family list none.
+Reasoning models reject sampling parameters such as `temperature`; wardby
+doesn't send them. Reasoning tokens bill as output tokens, charged when the
+call ends, so one call can take a run past its budget by its reasoning; higher
+effort raises that ceiling.
+
+After an upgrade, a `set_model` override of a shipped model keeps its stored
+`efforts` (it replaces the shipped entry wholesale). If those are empty,
+`create_agent`/`update_agent` reject an `effort` for the model: run
+`reset_model`, or `set_model` again with the new efforts, to pick up shipped
+changes.
+
 A newly released Claude model may also need a newer Claude Code than your
 Claude Code worker image has: coding runs on it then fail as
 `provider_rejected` (no cost) while native runs work. Upgrade wardby and

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wardby/cli",
-  "version": "0.5.1",
+  "version": "0.5.2",
   "description": "Self-hosted control plane for budget-guarded AI agents.",
   "license": "Apache-2.0",
   "homepage": "https://github.com/wardby/wardby#readme",