dsh-ai-arcade 0.0.0-stage → 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 dsh-ai-arcade contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,88 @@
-# Temporary Holding Version
+# dsh-ai-arcade
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+**AI 街机厅** —— 在 [DeepSeek Harness](https://deepseek.com/harness/en/) 里玩游戏，对手是有脑子的：**模型负责「想」，本地引擎负责「动」**。
+
+点左下角的 🎮 打开面板，里面是一个完整的街机厅。
+
+| 游戏 | 模型做什么 | 本地做什么 |
+|---|---|---|
+| 🐍 **双脑贪吃蛇** | 每 1.7 秒出一张**策略卡**（目标 / 激进程度 / 风险偏好）+ 一句挑衅 | 按 60fps 跑规则、按策略卡决定每一步、模型慢或挂了自动兜底 |
+| ♟ **中国象棋** | 只**解说**（从引擎给的候选里挑一个 + 说一句心理活动） | 走法生成、合法性校验、alpha-beta 搜索 —— **全部棋力** |
+
+## 为什么模型不直接下棋 / 不直接控制蛇
+
+因为它做不到，而且实测数据很清楚：
+
+- **象棋**：马腿、象眼、炮架、将帅照面这些规则一旦交给模型，非法棋是常态；就算合法，几百行的搜索也轻松赢它。所以模型只被允许**从本地给出的合法候选里挑一个**——非法棋因此不可能出现。
+- **贪吃蛇**：单次模型往返 **0.8–2 秒**，而游戏一步只要 140 毫秒。所以模型只出**意图**，具体走法由本地引擎算。
+- **还有一个坑**：宿主默认的 `reasoningEffort` 是 `high`，实测一次游戏规模的提问会**烧掉 2048 个输出 token 全在思考块里、耗时 17 秒、正文为空**。这个插件显式要 `off`，同样的提问变成 **0.78 秒、37 个 token、回答完整**。
+
+断网、模型超时、额度用尽 —— 两个游戏都照常运行，只是少了那张嘴。
+
+## 安装
+
+```sh
+dsh plugin --profile <你的 profile> add dsh-ai-arcade
+```
+
+装好后点界面左下角的 **🎮**。
+
+## 配置
+
+写在 profile 补丁层，或直接在设置页改：
+
+```yaml
+- insert:
+    - id: dsh-ai-arcade
+      name: dsh-ai-arcade
+      config:
+        enabled: true
+        provider: deepseek-account   # 留空则自动挑第一个可用 provider
+        model: deepseek-flash
+        reasoningEffort: "off"       # 游戏要快；深度复盘时可以单独覆盖
+        maxTokens: 2048
+        timeoutMs: 45000
+```
+
+## 架构
+
+```
+🎮 按钮（插件客户端 bundle：一枚按钮 + 一个 iframe）
+  └─ <iframe src="/api/dsh-ai-arcade/play">
+        └─ 游戏页面（宿主路由，每次现读磁盘，no-store）
+              └─ fetch /api/dsh-ai-arcade/brain
+                    └─ ctx.llm.stream()  ← 凭证留在主进程
+```
+
+**游戏本体为什么不在插件的客户端 bundle 里**：DSH 把所有插件的浏览器半边聚合成一个响应，带一年 `immutable` 强缓存，服务端也缓存这份聚合；改客户端代码必须重启 DSH。把游戏放到宿主路由提供的页面上（`no-store`）之后，改玩法只要刷新页面 —— 这个插件在加入象棋、暂停功能的整个过程中没有重启过。
+
+反过来，插件那一半只当"壳"，几乎不需要改。
+
+### 操作模式
+
+- **双脑贪吃蛇**：单步（点一次走一格、听 AI 的理由）／实时对战（两条蛇自己打）／我来玩（方向键操控蓝蛇）
+- **中国象棋**：人机对弈（你执红）／AI 对弈（看它自己下）；难度滑杆 1–10，同时调搜索深度与"失误率"
+- 两个游戏都有 **⏸ 暂停**（快捷键 `P`）
+
+## 开发
+
+```sh
+npm run build        # esbuild 打包客户端壳与游戏页面（需 Node 22+）
+npm test             # 38 项打包自检 + 14 项象棋引擎测试
+```
+
+改游戏只需重新构建页面并覆盖 `lib/play.html`，然后刷新浏览器；改服务端或壳需要重启 DSH。
+
+## 测试覆盖
+
+`node --test test/xiangqi.test.mjs` —— 14 项，包括：
+
+- **开局着法数 44**（中国象棋标准值），逐子分解断言（车 4 + 马 4 + 相 4 + 仕 2 + 帅 1 + 兵 5 + 炮 24）
+- 马腿、象眼、象不过河、炮必须有炮架才能吃、兵过河才能横走
+- 将帅照面视为将军、被将军时只能走应将着法、make/undo 往返一致
+- 识别双车错将死、搜索能白吃车、能认出一手绝杀
+- 难度滑杆：10 级 20/20 选最优，1 级会失手
+
+## License
+
+MIT

package/cordis.patch.yml

@@ -0,0 +1,11 @@
+# dsh-ai-arcade：往插件树里插一行（宿主半边提供 LLM 大脑路由，浏览器半边挂一个游戏面板）。
+# 注：name 必须等于包名；id 是本地行标识（也是设置页命名空间）。
+- insert:
+    - id: dsh-ai-arcade
+      name: dsh-ai-arcade
+      config:
+        enabled: true
+        provider: deepseek-account
+        model: deepseek-flash
+        maxTokens: 512
+        timeoutMs: 45000

package/lib/brain.js

@@ -0,0 +1,211 @@
+/**
+ * The brain seam — the only place this plugin talks to a model.
+ *
+ * Three responsibilities, kept out of the route so all of them stay testable:
+ *   1. resolve a usable `{ provider, model }` (configured value first, then the
+ *      first advertised pair — so the plugin still works on a profile that has
+ *      never heard of `deepseek-account`);
+ *   2. drive one `ctx.llm.stream()` call and hand back assembled text, pushing
+ *      each incremental piece to the caller so the browser can render the model
+ *      thinking in real time;
+ *   3. keep the reasoning budget honest. The host defaults `reasoningEffort` to
+ *      the model's declared default (high for the DeepSeek models on this box),
+ *      and at that effort a game-sized answer can spend the entire output budget
+ *      on the reasoning block and return an EMPTY text block — a "successful"
+ *      call that says nothing. This plugin therefore asks for `low` by default
+ *      and retries once without the knob if the model does not support it.
+ *
+ * Everything else model-shaped is the harness's job (credentials, adapters,
+ * retry, JSON mode) — the same seam `dsh-shift-router` uses for its Judge.
+ *
+ * @module dsh-ai-arcade/brain
+ */
+
+import { BlockAssembler, createUserMessage } from "@deepseek-ai/dsh-llm";
+
+/** The opponent's standing character. Per-game tactics come in as the prompt. */
+export const BRAIN_SYSTEM = [
+	"你是「双脑贪吃蛇」里的 AI 玩家，控制右边那条蛇；玩家控制左边那条蛇。",
+	"你说话干脆、带一点自信的垃圾话，但每次不超过两句。",
+	"回答用中文，不要输出 JSON、不要用 Markdown 代码块。",
+].join("\n");
+
+/** Reasoning efforts the DeepSeek adapter advertises. `""` means "do not ask". */
+export const REASONING_EFFORTS = Object.freeze(["off", "low", "high", "max"]);
+
+/**
+ * Split an assembled call into its spoken text and its private reasoning.
+ *
+ * Both are returned: the game panel shows the reply as the answer and the
+ * reasoning as a dimmer "thinking" trace, which is exactly the "watch it think"
+ * affordance this plugin is built around.
+ *
+ * @param assembler - the live block assembler.
+ * @returns the concatenated `text` and `reasoning` blocks so far.
+ */
+function blocksOf(assembler) {
+	try {
+		let text = "";
+		let reasoning = "";
+		for (const block of assembler.blocks()) {
+			if (typeof block?.text !== "string") continue;
+			if (block.type === "text") text += block.text;
+			else if (block.type === "reasoning") reasoning += block.text;
+		}
+		return { text, reasoning };
+	} catch {
+		return { text: "", reasoning: "" };
+	}
+}
+
+/**
+ * A short human-readable reason from an adapter failure.
+ *
+ * @param failure - the failure carried by the assembler's finish state.
+ * @returns a message suitable for the game panel.
+ */
+function describeFailure(failure) {
+	if (failure === null || typeof failure !== "object") return "model call failed";
+	const message = failure.message ?? failure.code ?? failure.kind;
+	return typeof message === "string" && message !== "" ? message : "model call failed";
+}
+
+/**
+ * Resolve the provider/model pair this plugin should call.
+ *
+ * @param ctx - host plugin context (needs the `llm` service).
+ * @param settings - resolved plugin settings.
+ * @returns the pair, or null when the host advertises no usable model.
+ */
+export async function resolveTarget(ctx, settings) {
+	const provider = settings.provider;
+	const model = settings.model;
+	if (provider !== "" && model !== "") {
+		try {
+			await ctx.llm.resolveModelInfo(provider, model);
+			return { provider, model, source: "config" };
+		} catch {
+			// Fall through to discovery: a profile without this provider is not an error.
+		}
+	}
+	try {
+		const providers = ctx.llm.listProviders() ?? [];
+		for (const entry of providers) {
+			const id = typeof entry === "string" ? entry : entry?.id;
+			if (typeof id !== "string" || id === "") continue;
+			const models = await ctx.llm.listModels(id);
+			if (!Array.isArray(models)) continue;
+			const first = models.find((candidate) => typeof candidate === "string" && candidate !== "");
+			if (first !== undefined) return { provider: id, model: first, source: "auto" };
+		}
+	} catch {
+		// No discovery either — report the absence instead of guessing.
+	}
+	return null;
+}
+
+/**
+ * Drive one streamed brain call.
+ *
+ * @param ctx - host plugin context.
+ * @param options - system/prompt text, resolved target, caps, abort signal, an
+ *   `onDelta` callback for spoken text and an `onThought` callback for reasoning.
+ * @returns `{ ok: true, text, reasoning, usage }` or
+ *   `{ ok: false, text, reasoning, code, detail }`.
+ */
+export async function streamBrain(ctx, options) {
+	const { system, prompt, provider, model, maxTokens, temperature, reasoningEffort, signal, onDelta, onThought } =
+		options;
+
+	/**
+	 * One attempt, with or without an explicit reasoning effort.
+	 *
+	 * @param effort - `""` to leave the choice to the host.
+	 * @returns the attempt outcome.
+	 */
+	const attempt = async (effort) => {
+		const assembler = new BlockAssembler();
+		let sentText = "";
+		let sentThought = "";
+
+		/** Forward whatever incremental content arrived since the last call. */
+		const flush = () => {
+			const now = blocksOf(assembler);
+			if (now.text.length > sentText.length) {
+				const delta = now.text.slice(sentText.length);
+				sentText = now.text;
+				if (typeof onDelta === "function") onDelta(delta);
+			}
+			if (now.reasoning.length > sentThought.length) {
+				const delta = now.reasoning.slice(sentThought.length);
+				sentThought = now.reasoning;
+				if (typeof onThought === "function") onThought(delta);
+			}
+		};
+
+		const config = {
+			provider,
+			model,
+			system,
+			messages: [
+				createUserMessage({
+					content: [{ type: "text", text: prompt }],
+					source: { kind: "user" },
+				}),
+			],
+			temperature,
+			maxTokens,
+			signal,
+		};
+		if (typeof effort === "string" && effort !== "") config.reasoningEffort = effort;
+
+		const stream = ctx.llm.stream(config);
+		for await (const chunk of stream) {
+			assembler.push(chunk);
+			flush();
+		}
+		const finish = assembler.finish;
+		flush();
+
+		const blocks = blocksOf(assembler);
+		const usage = typeof assembler.usage === "object" ? assembler.usage : undefined;
+		if (finish !== undefined && finish !== null && (finish.kind === "error" || finish.kind === "aborted")) {
+			return {
+				ok: false,
+				text: blocks.text,
+				reasoning: blocks.reasoning,
+				code: finish.kind,
+				detail: describeFailure(finish.failure),
+				...(usage === undefined ? {} : { usage }),
+			};
+		}
+		return {
+			ok: true,
+			text: blocks.text,
+			reasoning: blocks.reasoning,
+			...(usage === undefined ? {} : { usage }),
+		};
+	};
+
+	try {
+		return await attempt(reasoningEffort);
+	} catch (error) {
+		const detail = error instanceof Error ? error.message : String(error);
+		// A model that advertises no reasoning support rejects the knob outright;
+		// the call itself is still fine, so retry once without it.
+		if (typeof reasoningEffort === "string" && reasoningEffort !== "" && /reasoning/i.test(detail)) {
+			try {
+				return await attempt("");
+			} catch (retryError) {
+				return {
+					ok: false,
+					text: "",
+					reasoning: "",
+					code: "stream-failed",
+					detail: retryError instanceof Error ? retryError.message : String(retryError),
+				};
+			}
+		}
+		return { ok: false, text: "", reasoning: "", code: "stream-failed", detail };
+	}
+}

package/lib/client.js

@@ -0,0 +1,113 @@
+/* generated by tools/build-client.mjs — edit src/client/ instead */
+window.__ModuleLoader__.load({
+	id: "dsh-ai-arcade",
+	factory: (require) => {
+		var module = { exports: {} };
+		var exports = module.exports;
+		var React = require("react");
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/client/index.js
+var index_exports = {};
+__export(index_exports, {
+  apply: () => apply,
+  inject: () => inject
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/client/panel.js
+var import_react = __toESM(require("react"), 1);
+var h = import_react.default.createElement;
+var PLAY_ROUTE = "/api/dsh-ai-arcade/play";
+var TAG_ID = "dsh-ai-arcade/arcade.css";
+var CSS = [
+  ".dsha_btn{box-sizing:border-box;position:fixed;left:16px;bottom:72px;z-index:2147483000;height:44px;min-width:44px;padding:0 14px;display:inline-flex;align-items:center;justify-content:center;gap:8px;border:none;border-radius:22px;background:#1f2430;color:#e6e8ee;box-shadow:0 6px 24px rgba(0,0,0,.35);cursor:pointer;user-select:none;font-size:16px;line-height:20px}",
+  ".dsha_btn:hover{background:#2a3140}",
+  ".dsha_panel{box-sizing:border-box;position:fixed;left:50%;top:50%;transform:translate(-50%,-50%);z-index:2147483000;width:min(96vw,1080px);height:min(90vh,720px);display:flex;flex-direction:column;gap:8px;padding:10px;border-radius:16px;background:#1f2430;color:#e6e8ee;box-shadow:0 20px 60px rgba(0,0,0,.55);font-size:13px}",
+  ".dsha_bar{flex:none;display:flex;align-items:center;gap:8px}",
+  ".dsha_title{font-size:14px;font-weight:600;line-height:20px}",
+  ".dsha_tag{font-size:11px;color:#6b7280}",
+  ".dsha_ghost{margin-left:auto;box-sizing:border-box;height:26px;padding:0 10px;border:1px solid #3a4150;border-radius:6px;background:transparent;color:#9aa2b1;cursor:pointer;font-size:12px}",
+  ".dsha_ghost+.dsha_ghost{margin-left:0}",
+  ".dsha_ghost:hover{background:#2a3140;color:#e6e8ee}",
+  ".dsha_frame{flex:1;min-height:0;width:100%;border:1px solid #3a4150;border-radius:12px;background:#14171d;display:block}"
+].join("");
+function ensureStyles() {
+  if (typeof document === "undefined") return;
+  if (document.querySelector(`style[data-plugin-css="${TAG_ID}"]`) !== null) return;
+  const style = document.createElement("style");
+  style.setAttribute("data-plugin-css", TAG_ID);
+  style.textContent = CSS;
+  document.head.appendChild(style);
+}
+function ArcadePanel() {
+  const [open, setOpen] = (0, import_react.useState)(false);
+  const [nonce, setNonce] = (0, import_react.useState)(0);
+  (0, import_react.useEffect)(() => {
+    ensureStyles();
+  }, []);
+  if (!open) {
+    return h("button", { className: "dsha_btn", title: "AI 街机厅", onClick: () => setOpen(true) }, "🎮");
+  }
+  return h("div", { className: "dsha_panel" }, [
+    h("div", { className: "dsha_bar", key: "bar" }, [
+      h("span", { className: "dsha_title", key: "t" }, "AI 街机厅"),
+      h("span", { className: "dsha_tag", key: "tag" }, "双脑贪吃蛇"),
+      h("button", { className: "dsha_ghost", key: "reload", onClick: () => setNonce((value) => value + 1) }, "重新载入"),
+      h("button", { className: "dsha_ghost", key: "close", onClick: () => setOpen(false) }, "收起 ✕")
+    ]),
+    h("iframe", {
+      className: "dsha_frame",
+      key: nonce,
+      src: `${PLAY_ROUTE}?v=${nonce}`,
+      title: "AI 街机厅"
+    })
+  ]);
+}
+
+// src/client/index.js
+var inject = ["slots"];
+function apply(ctx) {
+  ctx.slots.inject(
+    "shell.overlay",
+    () => ctx.slots.register(
+      {
+        name: "shell.overlay",
+        id: "dsh-ai-arcade:overlay",
+        order: 110,
+        inject: () => ({})
+      },
+      ArcadePanel
+    )
+  );
+}
+
+		return module.exports;
+	}
+});

package/lib/config.js

@@ -0,0 +1,116 @@
+/**
+ * Plugin configuration: the schema the host validates against, the code-side
+ * defaults (so a direct `apply()` call works without the loader), and the
+ * normalisation of every knob.
+ *
+ * The Cordis loader applies `Config` defaults, but `apply` is also reachable
+ * through direct construction (tests, tooling), so this module resolves its own
+ * defaults instead of trusting the caller.
+ *
+ * @module dsh-ai-arcade/config
+ */
+
+import z from "@deepseek-ai/schemastery";
+
+/** Reasoning efforts the DeepSeek adapter advertises. */
+const EFFORTS = ["off", "low", "high", "max"];
+
+/** Code-side defaults, mirrored by the `Config` schema below. */
+export const DEFAULTS = Object.freeze({
+	enabled: true,
+	provider: "deepseek-account",
+	model: "deepseek-flash",
+	// Measured on this box: at the host default (high) a game-sized prompt spends
+	// the whole output budget on the reasoning block and returns an EMPTY text
+	// block after ~9s; at `low` the same prompt answers in ~1-2s with text.
+	reasoningEffort: "low",
+	maxTokens: 2048,
+	timeoutMs: 45_000,
+	temperature: 0.7,
+	maxBodyBytes: 65_536,
+	// Not a feature: changing this string is what makes the loader re-read this
+	// plugin row, which is how a host-half edit (and the client bundle served
+	// from it) is picked up without restarting DSH. `tools/dev-sync.sh` bumps it.
+	devStamp: "",
+});
+
+export const Config = z.object({
+	/** Master switch; `false` registers no HTTP route and spends no credits. */
+	enabled: z.boolean().default(DEFAULTS.enabled),
+	/** Provider id for the game brain (empty = auto-pick the first usable one). */
+	provider: z.string().default(DEFAULTS.provider),
+	/** Model id for the game brain. */
+	model: z.string().default(DEFAULTS.model),
+	/** Reasoning budget per brain call: `off`, `low`, `high` or `max`. */
+	reasoningEffort: z.string().default(DEFAULTS.reasoningEffort),
+	/** Output cap per brain call. */
+	maxTokens: z.natural().default(DEFAULTS.maxTokens),
+	/** Hard ceiling on one brain call; the UI shows a timeout instead of hanging. */
+	timeoutMs: z.natural().default(DEFAULTS.timeoutMs),
+	/** Sampling temperature — higher makes the opponent more erratic/characterful. */
+	temperature: z.number().default(DEFAULTS.temperature),
+	/** Request body cap for the brain route. */
+	maxBodyBytes: z.natural().default(DEFAULTS.maxBodyBytes),
+	/** Development reload trigger; see {@link DEFAULTS.devStamp}. */
+	devStamp: z.string().default(DEFAULTS.devStamp),
+});
+
+/**
+ * One of `allowed`, or `fallback` when the value is absent/unknown.
+ *
+ * @param value - raw configured value.
+ * @param allowed - accepted strings.
+ * @param fallback - value used otherwise.
+ * @returns the resolved string.
+ */
+function pick(value, allowed, fallback) {
+	return typeof value === "string" && allowed.includes(value) ? value : fallback;
+}
+
+/**
+ * A finite number clamped into `[min, max]`, or `fallback`.
+ *
+ * @param value - raw configured value.
+ * @param min - lower bound.
+ * @param max - upper bound.
+ * @param fallback - value used otherwise.
+ * @returns the resolved number.
+ */
+function clampNumber(value, min, max, fallback) {
+	const number = Number(value);
+	if (!Number.isFinite(number)) return fallback;
+	return Math.min(max, Math.max(min, number));
+}
+
+/**
+ * A positive integer, or `fallback`.
+ *
+ * @param value - raw configured value.
+ * @param fallback - value used otherwise.
+ * @returns the resolved integer.
+ */
+function positiveInteger(value, fallback) {
+	const number = Number(value);
+	return Number.isSafeInteger(number) && number > 0 ? number : fallback;
+}
+
+/**
+ * Resolve user configuration into the plain settings object the plugin uses.
+ *
+ * @param raw - the loader-supplied config (possibly undefined).
+ * @returns resolved settings.
+ */
+export function resolveConfig(raw) {
+	const config = raw === null || typeof raw !== "object" ? {} : raw;
+	return {
+		enabled: config.enabled !== false,
+		provider: typeof config.provider === "string" ? config.provider.trim() : DEFAULTS.provider,
+		model: typeof config.model === "string" ? config.model.trim() : DEFAULTS.model,
+		reasoningEffort: pick(config.reasoningEffort, EFFORTS, DEFAULTS.reasoningEffort),
+		maxTokens: positiveInteger(config.maxTokens, DEFAULTS.maxTokens),
+		timeoutMs: positiveInteger(config.timeoutMs, DEFAULTS.timeoutMs),
+		temperature: clampNumber(config.temperature, 0, 2, DEFAULTS.temperature),
+		maxBodyBytes: positiveInteger(config.maxBodyBytes, DEFAULTS.maxBodyBytes),
+		devStamp: typeof config.devStamp === "string" ? config.devStamp : DEFAULTS.devStamp,
+	};
+}