@stackstackstack/dsh-llm-retry 0.1.5

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 DeepSeek
+
+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.i18n.yaml

@@ -0,0 +1,6 @@
+# Bilingual-pair consistency record (docs/i18n/README.md): the git blob hash of each
+# side as of the last confirmed-consistent state. Both languages carry equal authority;
+# after editing either side, bring the other along and re-record with:
+#   pnpm run verify-translation-pairing --write packages/llm/llm-retry/README.md
+README.md: 4f4a4209296581f7b275294123df0668034c51d0
+README.zh.md: dea6882d1c5107985d490a13eb67a5d0f4da5b3c

package/README.md

@@ -0,0 +1,53 @@
+# `@stackstackstack/dsh-llm-retry`
+
+English | [中文](README.zh.md)
+
+Function plugin that applies exact-provider retry policy through the agent loop's closed-step `agent/request-error` waterfall. It does not wrap `ctx.llm.stream()`: every adapter call remains one provider attempt, and every retry opens a fresh numbered turn.
+
+Each provider adapter owns an optional nested `retryPolicy`, captured when its route registers on `ctx.llm` and carried with each call that reaches that registration's final adapter boundary. An in-flight failure retains that serving policy if the route is later disposed or replaced; a failure before any final adapter is selected has no provider policy and delegates. Omission uses normal mode: two retries for `EMPTY_RESPONSE`, `RATE_LIMIT`, `SERVER`, `TIMEOUT`, and `TRANSPORT`, with bounded exponential backoff from 500 ms to 10 seconds and 10 percent jitter. `EMPTY_RESPONSE` is the adapters' classification of a degenerate provider completion that produced no durable content, so repeating it is safe. A normal policy can change its finite budget, eligible codes, and backoff. Always mode asks downstream recovery first, then retries every model-request failure without an attempt limit; success, cancellation, or plugin disposal stops it after active delegated recovery reaches quiescence.
+
+Both modes use bounded exponential backoff with symmetric jitter. A valid `providerRetryAfterMs` at or below `maxDelayMs` replaces local backoff without jitter. An over-cap provider delay makes normal mode delegate, while always mode uses its configured local backoff so it cannot terminate on that instruction.
+
+Before waiting, the plugin appends a non-surface `llm/retry` event with the shared `retryId`, provider, mode, canonical resolved-policy key, failure, and scheduled delay. Its payload is available from the browser-safe `@stackstackstack/dsh-llm-retry/types` subpath, so remote renderers can consume the durable status without loading the policy runtime. The key includes every behavior-affecting field and sorts normal-mode codes because eligibility uses set membership. Retry numbers continue only across events with the same provider and complete policy key, so a route replacement with different limits, code membership, or backoff starts its own history. Normal events include the finite maximum; always events omit it, and UIs render `∞`. When the wait completes, the plugin appends `llm/retry-started` with the same `retryId`, turn, step, and retry number immediately before returning `{ kind: 'retry' }`; cancellation during backoff writes no started event. The loop then closes the failed turn and opens a retry turn over the same durable history. Cancellation and plugin disposal abort active backoff, drain active delegated recovery before applying the abort, and make a callback captured before disposal fail closed.
+
+The separately published `./invariant` companion checks that every scheduled retry names the current open turn and latest closed step, matches the failed request's durable provider, carries non-empty provider and policy identities, has mode-specific bounds, a unique step record, the correct provider-policy retry number, and a bounded timer delay. It also requires each `llm/retry-started` event to name one prior scheduled attempt with the same `retryId`, turn, step, and retry number, and rejects repeated started events. Full jitter may schedule zero milliseconds at its lower boundary.
+
+```yaml
+- name: '@stackstackstack/dsh-llm-deepseek'
+  config:
+    apiKeyEnv: DEEPSEEK_API_KEY
+    retryPolicy:
+      mode: always
+      backoff:
+        initialDelayMs: 1000
+        maxDelayMs: 30000
+        jitterRatio: 0.2
+
+- name: '@stackstackstack/dsh-llm-retry'
+```
+
+The executor has no policy config. Multi-provider adapters such as `dsh-llm-pi-ai` place `retryPolicy` inside each provider profile, avoiding a second provider-name list.
+
+## Model Experience
+
+### Model-request recovery
+
+#### What the model sees
+
+No retry event, delay, provider error, or failed partial output is model-visible. The retry turn reconstructs the same explicit provider/model request from durable surface history unless a downstream recovery policy deliberately changes that surface; failed chunks never enter derived messages.
+
+#### Token effect
+
+Each retry is a new provider request and may repeat input-token billing. Normal mode has a finite budget; always mode can consume unbounded requests until success or cancellation. `llm/retry` itself contributes no tokens.
+
+#### KV Cache effect
+
+The reconstructed request preserves the prior prefix and is eligible for provider cache reuse under that provider's rules. The non-surface retry event does not change cache identity.
+
+## Known Limitations and Deferred Work
+
+- **Agent turns are the only retry boundary** — direct `ctx.llm.stream()` consumers remain single-attempt because a raw stream cannot separate already-emitted chunks durably.
+- **Always mode retries permanent failures** — authentication, quota, invalid-request, protocol, and unrecoverable context errors continue until success, cancellation, or disposal; deployments own provider-specific cost and latency controls.
+- **Finite plugin budgets add** — normal mode counts only its configured codes and exact provider policy, while context-overflow compaction owns a separate budget. Any overlapping policy must define registration-order behavior.
+- **Recovery policies compose by waterfall order** — always mode accepts a downstream retry before applying its fallback. A later policy that ignores cancellation and never settles also prevents fallback, turn quiescence, and plugin disposal from completing.
+- **`llm/retry` records scheduling, not completion** — later step and turn events establish success, exhaustion, or cancellation.

package/README.zh.md

@@ -0,0 +1,53 @@
+# `@stackstackstack/dsh-llm-retry`
+
+[English](README.md) | 中文
+
+一个函数插件，通过 agent loop（智能体循环）在已关闭步骤上触发的 `agent/request-error` waterfall（瀑布式事件）应用确切提供方重试策略。它不包装 `ctx.llm.stream()`：每次适配器调用仍是一次提供方尝试，每次重试都会开启新的编号轮次。
+
+每个提供方适配器都拥有可选的嵌套 `retryPolicy`；路由在 `ctx.llm` 上注册时会捕获该策略，任何到达该注册最终适配器边界的调用都会携带它。如果之后释放或替换路由，进行中的失败仍会保留当时为其提供服务的策略；在选中任何最终适配器前发生的失败没有提供方策略，会继续委托。省略策略时使用 normal mode：为 `EMPTY_RESPONSE`、`RATE_LIMIT`、`SERVER`、`TIMEOUT` 和 `TRANSPORT` 重试两次，并采用从 500 ms 到 10 秒的有界指数退避与 10% jitter。`EMPTY_RESPONSE` 是适配器对未产生任何持久内容的退化提供方完成所作的分类，因此可安全重复。normal 策略可以更改其有限预算、符合条件的 code 和退避配置。always mode 会先请求下游恢复，再无次数上限地重试每个模型请求失败；成功、取消或插件 dispose（资源释放）会在活跃的委托恢复完全停稳后终止它。
+
+两种 mode 都使用带对称 jitter 的有界指数退避。有效 `providerRetryAfterMs` 不超过 `maxDelayMs` 时会替换本地退避，并且不加 jitter。超出上限的提供方延迟会使 normal mode 继续委托；always mode 则改用已配置的本地退避，避免该指令终止重试。
+
+等待前，插件会追加一条不进入表层的 `llm/retry` 事件，其中包含共享 `retryId`、提供方、mode、已解析策略的规范 key、失败和计划延迟。该载荷由可安全用于浏览器的 `@stackstackstack/dsh-llm-retry/types` 子路径导出，因此远程渲染器无需加载策略运行时即可使用该持久状态。该 key 包含所有影响行为的字段，并对 normal mode 的 code 排序，因为合格性采用集合成员关系判断。只有提供方与完整策略 key 都相同的事件才会延续重试编号；因此，用限制、code 成员关系或退避不同的路由替换后，会开始自己的历史。normal 事件包含有限上限；always 事件省略该上限，UI 会渲染 `∞`。等待完成时，插件会在返回 `{ kind: 'retry' }` 前立即追加 `llm/retry-started`，其中带有相同的 `retryId`、轮次、步骤与重试编号；退避期间取消则不会写入 started 事件。随后循环关闭失败轮次，并在同一持久历史上开启重试轮次。取消与插件 dispose 会中止活跃退避，在应用中止前等待活跃的委托恢复结算，并使 dispose 前捕获的 callback 只能以失败结束。
+
+单独发布的 `./invariant` 配套模块会检查每个已调度重试是否指向当前开启轮次及其最新已关闭步骤，是否与失败请求的持久提供方匹配，是否携带非空的提供方与策略标识，是否满足 mode 特定边界，是否拥有唯一步骤记录和正确的提供方策略重试编号，以及是否携带有界定时器延迟。它还要求每个 `llm/retry-started` 事件通过相同的 `retryId`、轮次、步骤与重试编号指向一个先前调度的尝试，并拒绝重复的 started 事件。full jitter 可以在下界调度为零毫秒。
+
+```yaml
+- name: '@stackstackstack/dsh-llm-deepseek'
+  config:
+    apiKeyEnv: DEEPSEEK_API_KEY
+    retryPolicy:
+      mode: always
+      backoff:
+        initialDelayMs: 1000
+        maxDelayMs: 30000
+        jitterRatio: 0.2
+
+- name: '@stackstackstack/dsh-llm-retry'
+```
+
+执行器没有策略配置。`dsh-llm-pi-ai` 等多提供方适配器会把 `retryPolicy` 放在每个提供方 profile 内，避免维护第二份提供方名称列表。
+
+## 模型体验
+
+### 模型请求恢复
+
+#### 模型看到的内容
+
+模型不会看到重试事件、延迟、提供方错误或失败的部分输出。重试轮次会从持久表层历史中重建相同的显式提供方／模型请求，除非下游恢复策略有意更改该表层；失败分片绝不会进入派生消息。
+
+#### Token 影响
+
+每次重试都是新的提供方请求，可能重复计费输入 token。normal mode 具有有限预算；always mode 可以在成功或取消前消耗无界数量的请求。`llm/retry` 自身不产生 token。
+
+#### KV Cache 影响
+
+重建请求保留之前的前缀，并可根据该提供方的规则复用 cache。非表层重试事件不会改变 cache 身份。
+
+## 已知限制与暂缓事项
+
+- **agent 轮次是唯一重试边界**：直接 `ctx.llm.stream()` 消费方仍只尝试一次，因为原始流无法持久地区分各次尝试已经发出的分片。
+- **always mode 会重试永久性失败**：身份验证、配额、无效请求、协议和无法恢复的上下文错误都会继续重试，直至成功、取消或 dispose；部署负责提供方特定的成本与延迟控制。
+- **有限插件预算可叠加**：normal mode 只统计已配置 code 和确切提供方策略，上下文溢出压缩（compaction）则拥有独立预算。任何重叠策略都必须定义注册顺序行为。
+- **恢复策略按 waterfall 顺序组合**：always mode 会先接受下游重试，再应用自己的回退。后续策略如果忽略取消且永不结算，也会阻止回退、轮次完全停稳和插件 dispose 完成。
+- **`llm/retry` 记录调度，不是完成**：后续步骤与轮次事件用于确立成功、耗尽或取消。

package/lib/index.js

@@ -0,0 +1,164 @@
+import { randomUUID } from "node:crypto";
+import z from "@deepseek-ai/schemastery";
+//#region lib/types/brand.js
+/**
+* Brand an implementation-minted retry-chain identity.
+* @param id - opaque retry identity.
+* @returns the same string, branded; no validation is performed.
+*/
+function RetryId(id) {
+	return id;
+}
+//#endregion
+//#region lib/types/index.js
+/**
+* Provider-routed model-request retry policy on the agent loop's request
+* recovery extension point. Each scheduled retry is durable before its cancellable wait.
+*
+* @module @stackstackstack/dsh-llm-retry
+*/
+const name = "llm-retry";
+const inject = ["agents"];
+/** Runtime schema for {@link Config}. */
+const Config = z.object({});
+function validateConfig(config) {
+	const [key] = Object.keys(config);
+	if (key === void 0) return;
+	if (key === "retryPolicy") throw new Error("llm-retry: retryPolicy belongs under each provider configuration");
+	throw new Error(`llm-retry: unknown key "${key}"`);
+}
+async function settleDownstream(next) {
+	try {
+		return {
+			type: "decision",
+			decision: await next()
+		};
+	} catch (error) {
+		return {
+			type: "error",
+			error
+		};
+	}
+}
+function localDelay(config, retry, random) {
+	const exponent = Math.min(retry - 1, 1024);
+	const exponential = Math.min(config.initialDelayMs * 2 ** exponent, config.maxDelayMs);
+	const jitter = 1 - config.jitterRatio + 2 * config.jitterRatio * random();
+	return Math.min(exponential * jitter, config.maxDelayMs);
+}
+function retryPolicyKey(policy) {
+	return policy.mode === "always" ? JSON.stringify([
+		policy.mode,
+		policy.initialDelayMs,
+		policy.maxDelayMs,
+		policy.jitterRatio
+	]) : JSON.stringify([
+		policy.mode,
+		policy.maxRetries,
+		[...policy.retryableCodes].sort(),
+		policy.initialDelayMs,
+		policy.maxDelayMs,
+		policy.jitterRatio
+	]);
+}
+function cancellableDelay(delayMs, signal) {
+	if (signal.aborted) return Promise.resolve(false);
+	return new Promise((resolve) => {
+		const timer = setTimeout(() => {
+			signal.removeEventListener("abort", onAbort);
+			resolve(true);
+		}, delayMs);
+		function onAbort() {
+			clearTimeout(timer);
+			resolve(false);
+		}
+		signal.addEventListener("abort", onAbort, { once: true });
+	});
+}
+/**
+* Install provider-routed normal or unbounded request recovery.
+* @param ctx - plugin context that owns the listener and active waits.
+* @param config - empty executor config; provider registrations own policy.
+* @param internals - non-serializable deterministic hooks for tests.
+*/
+function apply(ctx, config = {}, internals = {}) {
+	validateConfig(config);
+	const random = internals.random ?? Math.random;
+	const lifetime = new AbortController();
+	const active = /* @__PURE__ */ new Set();
+	function track(operation) {
+		const tracked = operation.finally(() => active.delete(tracked));
+		active.add(tracked);
+		return tracked;
+	}
+	async function backoff(agent, turn, step, failure, provider, policy, policyKey, retry, retryId, delayMs, signal) {
+		const fusedSignal = AbortSignal.any([signal, lifetime.signal]);
+		if (fusedSignal.aborted) return;
+		const eventData = policy.mode === "normal" ? {
+			retryId,
+			turn,
+			step,
+			provider,
+			mode: policy.mode,
+			policyKey,
+			retry,
+			maxRetries: policy.maxRetries,
+			delayMs,
+			failure
+		} : {
+			retryId,
+			turn,
+			step,
+			provider,
+			mode: policy.mode,
+			policyKey,
+			retry,
+			delayMs,
+			failure
+		};
+		agent.session.append("llm/retry", eventData);
+		if (!await cancellableDelay(delayMs, fusedSignal)) return;
+		agent.session.append("llm/retry-started", {
+			retryId,
+			turn,
+			step,
+			retry
+		});
+		return { kind: "retry" };
+	}
+	async function recover({ agent, turn, step, provider, failure, retryPolicy: policy, signal }, next) {
+		if (policy === void 0) return next();
+		if (policy.mode === "always") {
+			if (signal.aborted || lifetime.signal.aborted) return;
+			const fusedSignal = AbortSignal.any([signal, lifetime.signal]);
+			const downstream = await settleDownstream(next);
+			if (fusedSignal.aborted) return;
+			if (downstream.type === "error") ctx.logger.warn(`llm-retry: provider "${provider}" always policy ignored a downstream recovery failure: %o`, downstream.error);
+			if (downstream.type === "decision" && downstream.decision?.kind === "retry") return downstream.decision;
+		} else if (!policy.retryableCodes.includes(failure.code)) return next();
+		const policyKey = retryPolicyKey(policy);
+		const priorPolicyRetry = agent.session.events.findLast((event) => event.type === "llm/retry" && event.data.turn === turn && event.data.step === step && event.data.provider === provider && event.data.policyKey === policyKey);
+		const previousRetry = priorPolicyRetry?.data.retry ?? 0;
+		if (policy.mode === "normal" && previousRetry >= policy.maxRetries) return next();
+		const retry = previousRetry + 1;
+		const retryId = priorPolicyRetry?.data.retryId ?? RetryId(randomUUID());
+		let delayMs;
+		if (failure.providerRetryAfterMs !== void 0 && Number.isFinite(failure.providerRetryAfterMs) && failure.providerRetryAfterMs > 0) if (failure.providerRetryAfterMs > policy.maxDelayMs) {
+			if (policy.mode === "normal") return next();
+			delayMs = localDelay(policy, retry, random);
+		} else delayMs = failure.providerRetryAfterMs;
+		else delayMs = localDelay(policy, retry, random);
+		return backoff(agent, turn, step, failure, provider, policy, policyKey, retry, retryId, delayMs, signal);
+	}
+	const disposeListener = ctx.on("agent/request-error", (payload, next) => {
+		if (lifetime.signal.aborted) return Promise.resolve(void 0);
+		return track(recover(payload, next));
+	});
+	ctx.effect(() => async () => {
+		disposeListener();
+		lifetime.abort(/* @__PURE__ */ new Error("llm-retry plugin disposed"));
+		await Promise.allSettled([...active]);
+	}, "llm-retry: abort and drain active recovery");
+}
+//#endregion
+export { Config, RetryId, apply, inject, name };

package/lib/invariant.js

@@ -0,0 +1,108 @@
+import { MAX_TIMER_DELAY_MS } from "@stackstackstack/dsh-timeout";
+//#region lib/types/history.js
+/** Durable request-route lookup for one open model step. @module @stackstackstack/dsh-llm-retry/history */
+/**
+* Find the provider in force for one currently open step.
+* Request headers remain effective across turn boundaries until a newer full
+* snapshot changes them; every provider change requires a newer full snapshot.
+* @param events - session events ending inside the open step.
+* @param turn - turn that owns the failed step.
+* @param step - failed step whose provider is required.
+* @returns the provider from the request header in force for the step.
+*/
+function providerForOpenStep(events, turn, step) {
+	const stepStartIndex = events.findLastIndex((event) => event.type === "step/start" && event.data.turn === turn && event.data.step === step);
+	if (stepStartIndex < 0 || events.slice(stepStartIndex + 1).some((event) => event.type === "step/end" || event.type === "turn/end")) return void 0;
+	for (let index = events.length - 1; index >= 0; index -= 1) {
+		const event = events[index];
+		if (event.type === "request/header") return event.data.header.config.provider;
+	}
+}
+//#endregion
+//#region lib/types/invariant.js
+/** Package-owned durable retry-event invariants. @module @stackstackstack/dsh-llm-retry/invariant */
+const PACKAGE_NAME = "@stackstackstack/dsh-llm-retry";
+/** Cordis companion plugin name. */
+const name = "llm-retry-invariant";
+/** Service required before the companion can reserve package ownership. */
+const inject = ["invariants"];
+/** Validate the complete provider-neutral failure payload at the durable boundary. */
+function validateFailure(value, fail) {
+	if (typeof value !== "object" || value === null) fail("llm/retry failure must be an object");
+	const failure = value;
+	if (typeof failure.message !== "string" || failure.message.length === 0) fail("llm/retry failure.message must be a non-empty string");
+	if (typeof failure.code !== "string" || failure.code.length === 0) fail("llm/retry failure.code must be a non-empty string");
+	if (failure.status !== void 0 && (!Number.isInteger(failure.status) || failure.status < 100 || failure.status > 599)) fail("llm/retry failure.status must be an integer from 100 through 599 when present");
+	if (failure.providerRetryAfterMs !== void 0 && (!Number.isFinite(failure.providerRetryAfterMs) || failure.providerRetryAfterMs <= 0)) fail("llm/retry failure.providerRetryAfterMs must be a positive finite number when present");
+	if (failure.requestId !== void 0 && (typeof failure.requestId !== "string" || failure.requestId.length === 0)) fail("llm/retry failure.requestId must be a non-empty string when present");
+}
+/** Validate one retry record against the currently open request step. */
+function validateRetry(history, event, fail) {
+	const { retryId, turn, step, provider, mode, policyKey, retry, delayMs } = event.data;
+	if (typeof retryId !== "string" || retryId.length === 0) fail("llm/retry retryId must be a non-empty string");
+	const failure = event.data.failure;
+	validateFailure(failure, fail);
+	if (!Number.isSafeInteger(retry) || retry < 1) fail("llm/retry retry must be a positive safe integer");
+	if (typeof provider !== "string" || provider.length === 0) fail("llm/retry provider must be a non-empty string");
+	if (typeof policyKey !== "string" || policyKey.length === 0) fail("llm/retry policyKey must be a non-empty string");
+	switch (mode) {
+		case "normal": {
+			const { maxRetries } = event.data;
+			if (!Number.isSafeInteger(maxRetries) || maxRetries < 1 || retry > maxRetries) fail(`llm/retry retry ${retry} must not exceed a positive safe maxRetries ${maxRetries}`);
+			break;
+		}
+		case "always":
+			if ("maxRetries" in event.data) fail("llm/retry always mode must omit maxRetries");
+			break;
+		default: fail(`llm/retry mode must be normal or always, got ${String(mode)}`);
+	}
+	if (typeof delayMs !== "number" || !Number.isFinite(delayMs) || delayMs < 0 || delayMs > MAX_TIMER_DELAY_MS) fail(`llm/retry delayMs must be a finite number within 0..${MAX_TIMER_DELAY_MS}`);
+	const turnBoundary = history.findLast((prior) => prior.type === "turn/start" || prior.type === "turn/end");
+	if (turnBoundary?.type !== "turn/start") fail("llm/retry must be appended inside an open turn");
+	if (turn !== turnBoundary.data.turn) fail(`llm/retry names turn ${turn}, but the open turn is ${turnBoundary.data.turn}`);
+	const stepBoundary = history.findLast((prior) => prior.type === "step/start" || prior.type === "step/end");
+	if (stepBoundary?.type !== "step/start") fail("llm/retry must be appended inside an open step");
+	if (step !== stepBoundary.data.step || turn !== stepBoundary.data.turn) fail(`llm/retry names turn ${turn}/step ${step}, but the open step is ${stepBoundary.data.turn}/${stepBoundary.data.step}`);
+	const routedProvider = providerForOpenStep(history, turn, step);
+	if (routedProvider !== provider) fail(`llm/retry provider ${provider} does not match the failed request provider ${String(routedProvider)}`);
+	const priorPolicyRetry = history.findLast((prior) => prior.type === "llm/retry" && prior.data.turn === turn && prior.data.step === step && prior.data.provider === provider && prior.data.policyKey === policyKey);
+	const expectedRetry = (priorPolicyRetry?.data.retry ?? 0) + 1;
+	if (retry !== expectedRetry) fail(`llm/retry retry ${retry} must equal provider policy retry ${expectedRetry}`);
+	if (priorPolicyRetry !== void 0 && priorPolicyRetry.data.retryId !== retryId) fail("llm/retry must preserve retryId across one provider-policy chain");
+	if (priorPolicyRetry === void 0 && history.some((prior) => (prior.type === "llm/retry" || prior.type === "llm/retry-started") && prior.data.retryId === retryId)) fail(`llm/retry retryId ${JSON.stringify(retryId)} is already owned by another chain`);
+}
+/** Validate one wait-complete transition against its scheduled attempt. */
+function validateStarted(history, event, fail) {
+	const { retryId, turn, step, retry } = event.data;
+	if (typeof retryId !== "string" || retryId.length === 0) fail("llm/retry-started retryId must be a non-empty string");
+	const scheduled = history.findLast((prior) => prior.type === "llm/retry" && prior.data.retryId === retryId && prior.data.retry === retry);
+	if (scheduled === void 0) fail("llm/retry-started pairs no prior scheduled attempt");
+	if (scheduled.data.turn !== turn || scheduled.data.step !== step) fail("llm/retry-started turn/step must match its scheduled attempt");
+	if (history.some((prior) => prior.type === "llm/retry-started" && prior.data.retryId === retryId && prior.data.retry === retry)) fail("llm/retry-started repeats one scheduled attempt");
+}
+/** Validate every retry record already present in one loaded session. */
+function validateSession(session, fail) {
+	for (const [index, event] of session.events.entries()) if (event.type === "llm/retry") validateRetry(session.events.slice(0, index), event, fail);
+	else if (event.type === "llm/retry-started") validateStarted(session.events.slice(0, index), event, fail);
+}
+/** Install validation for loaded and newly appended retry records. */
+const install = Object.assign((ctx, fail) => {
+	for (const session of ctx.sessions.list()) validateSession(session, fail);
+	ctx.on("session/created", (session) => {
+		validateSession(session, fail);
+	}, { global: true });
+	ctx.on("internal/dispatch", (_mode, eventName, args) => {
+		if (eventName !== "session/event") return;
+		const [session, event] = args;
+		if (event.type === "llm/retry") validateRetry(session.events, event, fail);
+		else if (event.type === "llm/retry-started") validateStarted(session.events, event, fail);
+	}, { global: true });
+}, { inject: ["sessions"] });
+/**
+* Register the LLM retry invariant companion.
+* @param ctx - Cordis context carrying the invariant service.
+* @returns the installed registration's disposer after setup succeeds.
+*/
+const apply = (ctx) => Promise.resolve(ctx.invariants.register(PACKAGE_NAME, install));
+//#endregion
+export { apply, inject, name };

package/lib/types/brand.d.ts

@@ -0,0 +1,10 @@
+import type { Branded } from '@stackstackstack/dsh-brand';
+/** Stable identity shared by every attempt in one request-step retry chain. */
+export type RetryId = Branded<'RetryId'>;
+/**
+ * Brand an implementation-minted retry-chain identity.
+ * @param id - opaque retry identity.
+ * @returns the same string, branded; no validation is performed.
+ */
+export declare function RetryId(id: string): RetryId;
+//# sourceMappingURL=brand.d.ts.map

package/lib/types/brand.js

@@ -0,0 +1,9 @@
+/**
+ * Brand an implementation-minted retry-chain identity.
+ * @param id - opaque retry identity.
+ * @returns the same string, branded; no validation is performed.
+ */
+export function RetryId(id) {
+    return id;
+}
+//# sourceMappingURL=brand.js.map

package/lib/types/history.d.ts

@@ -0,0 +1,13 @@
+/** Durable request-route lookup for one open model step. @module @stackstackstack/dsh-llm-retry/history */
+import type { SessionEvent } from '@stackstackstack/dsh-session';
+/**
+ * Find the provider in force for one currently open step.
+ * Request headers remain effective across turn boundaries until a newer full
+ * snapshot changes them; every provider change requires a newer full snapshot.
+ * @param events - session events ending inside the open step.
+ * @param turn - turn that owns the failed step.
+ * @param step - failed step whose provider is required.
+ * @returns the provider from the request header in force for the step.
+ */
+export declare function providerForOpenStep(events: readonly SessionEvent[], turn: number, step: number): string | undefined;
+//# sourceMappingURL=history.d.ts.map

package/lib/types/history.js

@@ -0,0 +1,26 @@
+/** Durable request-route lookup for one open model step. @module @stackstackstack/dsh-llm-retry/history */
+/**
+ * Find the provider in force for one currently open step.
+ * Request headers remain effective across turn boundaries until a newer full
+ * snapshot changes them; every provider change requires a newer full snapshot.
+ * @param events - session events ending inside the open step.
+ * @param turn - turn that owns the failed step.
+ * @param step - failed step whose provider is required.
+ * @returns the provider from the request header in force for the step.
+ */
+export function providerForOpenStep(events, turn, step) {
+    const stepStartIndex = events.findLastIndex(event => event.type === 'step/start'
+        && event.data.turn === turn
+        && event.data.step === step);
+    if (stepStartIndex < 0 || events.slice(stepStartIndex + 1).some(event => event.type === 'step/end' || event.type === 'turn/end'))
+        return undefined;
+    for (let index = events.length - 1; index >= 0; index -= 1) {
+        // The loop bounds prove this indexed read exists.
+        // oxlint-disable-next-line typescript/no-non-null-assertion
+        const event = events[index];
+        if (event.type === 'request/header')
+            return event.data.header.config.provider;
+    }
+    return undefined;
+}
+//# sourceMappingURL=history.js.map

package/lib/types/index.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Provider-routed model-request retry policy on the agent loop's request
+ * recovery extension point. Each scheduled retry is durable before its cancellable wait.
+ *
+ * @module @stackstackstack/dsh-llm-retry
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import z from '@deepseek-ai/schemastery';
+export type { LlmRetryEventData, LlmRetryStartedEventData } from './types.ts';
+export { RetryId } from './brand.ts';
+export declare const name = "llm-retry";
+export declare const inject: string[];
+/** This policy executor has no config; providers own `retryPolicy`. */
+export type Config = Readonly<Record<string, never>>;
+/** Runtime schema for {@link Config}. */
+export declare const Config: z<Config>;
+/** Non-serializable hooks used to make timing policy deterministic in tests. */
+export interface RetryInternals {
+    /** Random sample in the inclusive zero-to-one range used for jitter. */
+    random?: () => number;
+}
+/**
+ * Install provider-routed normal or unbounded request recovery.
+ * @param ctx - plugin context that owns the listener and active waits.
+ * @param config - empty executor config; provider registrations own policy.
+ * @param internals - non-serializable deterministic hooks for tests.
+ */
+export declare function apply(ctx: Context, config?: Config, internals?: RetryInternals): void;
+//# sourceMappingURL=index.d.ts.map

package/lib/types/index.js

@@ -0,0 +1,180 @@
+/**
+ * Provider-routed model-request retry policy on the agent loop's request
+ * recovery extension point. Each scheduled retry is durable before its cancellable wait.
+ *
+ * @module @stackstackstack/dsh-llm-retry
+ */
+import { randomUUID } from 'node:crypto';
+import z from '@deepseek-ai/schemastery';
+import { RetryId } from "./brand.js";
+export { RetryId } from "./brand.js";
+export const name = 'llm-retry';
+export const inject = ['agents'];
+/** Runtime schema for {@link Config}. */
+export const Config = z.object({});
+function validateConfig(config) {
+    const [key] = Object.keys(config);
+    if (key === undefined)
+        return;
+    if (key === 'retryPolicy') {
+        throw new Error('llm-retry: retryPolicy belongs under each provider configuration');
+    }
+    throw new Error(`llm-retry: unknown key "${key}"`);
+}
+async function settleDownstream(next) {
+    try {
+        return { type: 'decision', decision: await next() };
+    }
+    catch (error) {
+        return { type: 'error', error };
+    }
+}
+function localDelay(config, retry, random) {
+    const exponent = Math.min(retry - 1, 1024);
+    const exponential = Math.min(config.initialDelayMs * 2 ** exponent, config.maxDelayMs);
+    const jitter = 1 - config.jitterRatio + 2 * config.jitterRatio * random();
+    return Math.min(exponential * jitter, config.maxDelayMs);
+}
+function retryPolicyKey(policy) {
+    return policy.mode === 'always'
+        ? JSON.stringify([policy.mode, policy.initialDelayMs, policy.maxDelayMs, policy.jitterRatio])
+        : JSON.stringify([
+            policy.mode,
+            policy.maxRetries,
+            [...policy.retryableCodes].sort(),
+            policy.initialDelayMs,
+            policy.maxDelayMs,
+            policy.jitterRatio,
+        ]);
+}
+function cancellableDelay(delayMs, signal) {
+    if (signal.aborted)
+        return Promise.resolve(false);
+    return new Promise((resolve) => {
+        const timer = setTimeout(() => {
+            signal.removeEventListener('abort', onAbort);
+            resolve(true);
+        }, delayMs);
+        function onAbort() {
+            clearTimeout(timer);
+            resolve(false);
+        }
+        signal.addEventListener('abort', onAbort, { once: true });
+    });
+}
+/**
+ * Install provider-routed normal or unbounded request recovery.
+ * @param ctx - plugin context that owns the listener and active waits.
+ * @param config - empty executor config; provider registrations own policy.
+ * @param internals - non-serializable deterministic hooks for tests.
+ */
+export function apply(ctx, config = {}, internals = {}) {
+    validateConfig(config);
+    const random = internals.random ?? Math.random;
+    const lifetime = new AbortController();
+    const active = new Set();
+    function track(operation) {
+        const tracked = operation.finally(() => active.delete(tracked));
+        active.add(tracked);
+        return tracked;
+    }
+    async function backoff(agent, turn, step, failure, provider, policy, policyKey, retry, retryId, delayMs, signal) {
+        const fusedSignal = AbortSignal.any([signal, lifetime.signal]);
+        if (fusedSignal.aborted)
+            return;
+        const eventData = policy.mode === 'normal'
+            ? {
+                retryId,
+                turn,
+                step,
+                provider,
+                mode: policy.mode,
+                policyKey,
+                retry,
+                maxRetries: policy.maxRetries,
+                delayMs,
+                failure,
+            }
+            : {
+                retryId,
+                turn,
+                step,
+                provider,
+                mode: policy.mode,
+                policyKey,
+                retry,
+                delayMs,
+                failure,
+            };
+        agent.session.append('llm/retry', eventData);
+        if (!await cancellableDelay(delayMs, fusedSignal))
+            return;
+        agent.session.append('llm/retry-started', { retryId, turn, step, retry });
+        return { kind: 'retry' };
+    }
+    async function recover({ agent, turn, step, provider, failure, retryPolicy: policy, signal }, next) {
+        if (policy === undefined)
+            return next();
+        if (policy.mode === 'always') {
+            if (signal.aborted || lifetime.signal.aborted)
+                return;
+            const fusedSignal = AbortSignal.any([signal, lifetime.signal]);
+            // The loop and plugin lifetime stay open until delegated recovery settles.
+            // An abort then wins before the decision or fallback can mutate later state.
+            const downstream = await settleDownstream(next);
+            if (fusedSignal.aborted)
+                return;
+            if (downstream.type === 'error') {
+                ctx.logger.warn(`llm-retry: provider "${provider}" always policy ignored a downstream recovery failure: %o`, downstream.error);
+            }
+            if (downstream.type === 'decision' && downstream.decision?.kind === 'retry') {
+                return downstream.decision;
+            }
+        }
+        else if (!policy.retryableCodes.includes(failure.code)) {
+            return next();
+        }
+        const policyKey = retryPolicyKey(policy);
+        const priorPolicyRetry = agent.session.events.findLast((event) => event.type === 'llm/retry'
+            && event.data.turn === turn
+            && event.data.step === step
+            && event.data.provider === provider
+            && event.data.policyKey === policyKey);
+        const previousRetry = priorPolicyRetry?.data.retry ?? 0;
+        if (policy.mode === 'normal' && previousRetry >= policy.maxRetries)
+            return next();
+        const retry = previousRetry + 1;
+        const retryId = priorPolicyRetry?.data.retryId ?? RetryId(randomUUID());
+        let delayMs;
+        if (failure.providerRetryAfterMs !== undefined
+            && Number.isFinite(failure.providerRetryAfterMs)
+            && failure.providerRetryAfterMs > 0) {
+            if (failure.providerRetryAfterMs > policy.maxDelayMs) {
+                if (policy.mode === 'normal')
+                    return next();
+                delayMs = localDelay(policy, retry, random);
+            }
+            else {
+                delayMs = failure.providerRetryAfterMs;
+            }
+        }
+        else {
+            delayMs = localDelay(policy, retry, random);
+        }
+        return backoff(agent, turn, step, failure, provider, policy, policyKey, retry, retryId, delayMs, signal);
+    }
+    const disposeListener = ctx.on('agent/request-error', (payload, next) => {
+        // A waterfall may have captured this callback before its registration was
+        // removed. Lifetime cancellation must prevent that stale callback from
+        // entering a downstream policy after disposal.
+        if (lifetime.signal.aborted)
+            return Promise.resolve(undefined);
+        return track(recover(payload, next));
+    });
+    ctx.effect(() => async () => {
+        disposeListener();
+        lifetime.abort(new Error('llm-retry plugin disposed'));
+        await Promise.allSettled([...active]);
+    }, 'llm-retry: abort and drain active recovery');
+}
+//# sourceMappingURL=index.js.map

package/lib/types/invariant.d.ts

@@ -0,0 +1,13 @@
+/** Package-owned durable retry-event invariants. @module @stackstackstack/dsh-llm-retry/invariant */
+import type { Context } from '@deepseek-ai/cordis';
+/** Cordis companion plugin name. */
+export declare const name = "llm-retry-invariant";
+/** Service required before the companion can reserve package ownership. */
+export declare const inject: string[];
+/**
+ * Register the LLM retry invariant companion.
+ * @param ctx - Cordis context carrying the invariant service.
+ * @returns the installed registration's disposer after setup succeeds.
+ */
+export declare const apply: (ctx: Context) => Promise<() => void>;
+//# sourceMappingURL=invariant.d.ts.map

package/lib/types/invariant.js

@@ -0,0 +1,152 @@
+/** Package-owned durable retry-event invariants. @module @stackstackstack/dsh-llm-retry/invariant */
+import { MAX_TIMER_DELAY_MS } from '@stackstackstack/dsh-timeout';
+import { providerForOpenStep } from "./history.js";
+const PACKAGE_NAME = '@stackstackstack/dsh-llm-retry';
+/** Cordis companion plugin name. */
+export const name = 'llm-retry-invariant';
+/** Service required before the companion can reserve package ownership. */
+export const inject = ['invariants'];
+/** Validate the complete provider-neutral failure payload at the durable boundary. */
+function validateFailure(value, fail) {
+    if (typeof value !== 'object' || value === null) {
+        fail('llm/retry failure must be an object');
+    }
+    const failure = value;
+    if (typeof failure.message !== 'string' || failure.message.length === 0) {
+        fail('llm/retry failure.message must be a non-empty string');
+    }
+    if (typeof failure.code !== 'string' || failure.code.length === 0) {
+        fail('llm/retry failure.code must be a non-empty string');
+    }
+    if (failure.status !== undefined
+        && (!Number.isInteger(failure.status) || failure.status < 100 || failure.status > 599)) {
+        fail('llm/retry failure.status must be an integer from 100 through 599 when present');
+    }
+    if (failure.providerRetryAfterMs !== undefined
+        && (!Number.isFinite(failure.providerRetryAfterMs) || failure.providerRetryAfterMs <= 0)) {
+        fail('llm/retry failure.providerRetryAfterMs must be a positive finite number when present');
+    }
+    if (failure.requestId !== undefined
+        && (typeof failure.requestId !== 'string' || failure.requestId.length === 0)) {
+        fail('llm/retry failure.requestId must be a non-empty string when present');
+    }
+}
+/** Validate one retry record against the currently open request step. */
+function validateRetry(history, event, fail) {
+    const { retryId, turn, step, provider, mode, policyKey, retry, delayMs } = event.data;
+    if (typeof retryId !== 'string' || retryId.length === 0) {
+        fail('llm/retry retryId must be a non-empty string');
+    }
+    const failure = event.data.failure;
+    validateFailure(failure, fail);
+    if (!Number.isSafeInteger(retry) || retry < 1) {
+        fail('llm/retry retry must be a positive safe integer');
+    }
+    if (typeof provider !== 'string' || provider.length === 0) {
+        fail('llm/retry provider must be a non-empty string');
+    }
+    if (typeof policyKey !== 'string' || policyKey.length === 0) {
+        fail('llm/retry policyKey must be a non-empty string');
+    }
+    switch (mode) {
+        case 'normal': {
+            const { maxRetries } = event.data;
+            if (!Number.isSafeInteger(maxRetries) || maxRetries < 1 || retry > maxRetries) {
+                fail(`llm/retry retry ${retry} must not exceed a positive safe maxRetries ${maxRetries}`);
+            }
+            break;
+        }
+        case 'always':
+            if ('maxRetries' in event.data)
+                fail('llm/retry always mode must omit maxRetries');
+            break;
+        default:
+            fail(`llm/retry mode must be normal or always, got ${String(mode)}`);
+    }
+    if (typeof delayMs !== 'number' || !Number.isFinite(delayMs)
+        || delayMs < 0 || delayMs > MAX_TIMER_DELAY_MS) {
+        fail(`llm/retry delayMs must be a finite number within 0..${MAX_TIMER_DELAY_MS}`);
+    }
+    const turnBoundary = history.findLast(prior => prior.type === 'turn/start' || prior.type === 'turn/end');
+    if (turnBoundary?.type !== 'turn/start') {
+        fail('llm/retry must be appended inside an open turn');
+    }
+    if (turn !== turnBoundary.data.turn) {
+        fail(`llm/retry names turn ${turn}, but the open turn is ${turnBoundary.data.turn}`);
+    }
+    const stepBoundary = history.findLast(prior => prior.type === 'step/start' || prior.type === 'step/end');
+    if (stepBoundary?.type !== 'step/start') {
+        fail('llm/retry must be appended inside an open step');
+    }
+    if (step !== stepBoundary.data.step || turn !== stepBoundary.data.turn) {
+        fail(`llm/retry names turn ${turn}/step ${step}, but the open step is ${stepBoundary.data.turn}/${stepBoundary.data.step}`);
+    }
+    const routedProvider = providerForOpenStep(history, turn, step);
+    if (routedProvider !== provider) {
+        fail(`llm/retry provider ${provider} does not match the failed request provider ${String(routedProvider)}`);
+    }
+    const priorPolicyRetry = history.findLast((prior) => prior.type === 'llm/retry'
+        && prior.data.turn === turn
+        && prior.data.step === step
+        && prior.data.provider === provider
+        && prior.data.policyKey === policyKey);
+    const expectedRetry = (priorPolicyRetry?.data.retry ?? 0) + 1;
+    if (retry !== expectedRetry) {
+        fail(`llm/retry retry ${retry} must equal provider policy retry ${expectedRetry}`);
+    }
+    if (priorPolicyRetry !== undefined && priorPolicyRetry.data.retryId !== retryId) {
+        fail('llm/retry must preserve retryId across one provider-policy chain');
+    }
+    if (priorPolicyRetry === undefined && history.some(prior => (prior.type === 'llm/retry' || prior.type === 'llm/retry-started')
+        && prior.data.retryId === retryId)) {
+        fail(`llm/retry retryId ${JSON.stringify(retryId)} is already owned by another chain`);
+    }
+}
+/** Validate one wait-complete transition against its scheduled attempt. */
+function validateStarted(history, event, fail) {
+    const { retryId, turn, step, retry } = event.data;
+    if (typeof retryId !== 'string' || retryId.length === 0) {
+        fail('llm/retry-started retryId must be a non-empty string');
+    }
+    const scheduled = history.findLast((prior) => prior.type === 'llm/retry' && prior.data.retryId === retryId && prior.data.retry === retry);
+    if (scheduled === undefined)
+        fail('llm/retry-started pairs no prior scheduled attempt');
+    if (scheduled.data.turn !== turn || scheduled.data.step !== step) {
+        fail('llm/retry-started turn/step must match its scheduled attempt');
+    }
+    if (history.some(prior => prior.type === 'llm/retry-started'
+        && prior.data.retryId === retryId && prior.data.retry === retry)) {
+        fail('llm/retry-started repeats one scheduled attempt');
+    }
+}
+/** Validate every retry record already present in one loaded session. */
+function validateSession(session, fail) {
+    for (const [index, event] of session.events.entries()) {
+        if (event.type === 'llm/retry')
+            validateRetry(session.events.slice(0, index), event, fail);
+        else if (event.type === 'llm/retry-started')
+            validateStarted(session.events.slice(0, index), event, fail);
+    }
+}
+/** Install validation for loaded and newly appended retry records. */
+const install = Object.assign((ctx, fail) => {
+    for (const session of ctx.sessions.list())
+        validateSession(session, fail);
+    ctx.on('session/created', (session) => { validateSession(session, fail); }, { global: true });
+    ctx.on('internal/dispatch', (_mode, eventName, args) => {
+        if (eventName !== 'session/event')
+            return;
+        const [session, event] = args;
+        if (event.type === 'llm/retry')
+            validateRetry(session.events, event, fail);
+        else if (event.type === 'llm/retry-started')
+            validateStarted(session.events, event, fail);
+    }, { global: true });
+}, { inject: ['sessions'] });
+/**
+ * Register the LLM retry invariant companion.
+ * @param ctx - Cordis context carrying the invariant service.
+ * @returns the installed registration's disposer after setup succeeds.
+ */
+export const apply = (ctx) => Promise.resolve(ctx.invariants.register(PACKAGE_NAME, install));
+//# sourceMappingURL=invariant.js.map

package/lib/types/types.d.ts

@@ -0,0 +1,42 @@
+import type { LlmFailure } from '@stackstackstack/dsh-llm/types';
+import type { RetryId } from './brand.ts';
+export type { RetryId };
+declare module '@stackstackstack/dsh-session/types' {
+    interface SessionEventMap {
+        /** Durable, non-surface record of one provider-routed retry scheduled after a failed request attempt. */
+        'llm/retry': LlmRetryEventData;
+        /** Durable transition written after a retry wait succeeds and before the next request attempt starts. */
+        'llm/retry-started': LlmRetryStartedEventData;
+    }
+}
+/** Durable payload recorded before one provider-routed model-request retry wait. */
+export type LlmRetryEventData = {
+    retryId: RetryId;
+    turn: number;
+    step: number;
+    provider: string;
+    mode: 'normal';
+    policyKey: string;
+    retry: number;
+    maxRetries: number;
+    delayMs: number;
+    failure: LlmFailure;
+} | {
+    retryId: RetryId;
+    turn: number;
+    step: number;
+    provider: string;
+    mode: 'always';
+    policyKey: string;
+    retry: number;
+    delayMs: number;
+    failure: LlmFailure;
+};
+/** Durable transition recorded after one retry delay completes. */
+export interface LlmRetryStartedEventData {
+    retryId: RetryId;
+    turn: number;
+    step: number;
+    retry: number;
+}
+//# sourceMappingURL=types.d.ts.map

package/lib/types/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/package.json

@@ -0,0 +1,69 @@
+{
+  "name": "@stackstackstack/dsh-llm-retry",
+  "description": "Provider-routed LLM request retry policy for the DeepSeek Harness",
+  "version": "0.1.5",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/deepseek-ai/deepseek-harness.git",
+    "directory": "packages/llm/llm-retry"
+  },
+  "type": "module",
+  "main": "lib/index.js",
+  "types": "lib/types/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./lib/types/index.d.ts",
+      "default": "./lib/index.js"
+    },
+    "./invariant": {
+      "types": "./lib/types/invariant.d.ts",
+      "default": "./lib/invariant.js"
+    },
+    "./types": {
+      "types": "./lib/types/types.d.ts",
+      "default": "./lib/types/types.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "lib/index.js",
+    "lib/invariant.js",
+    "lib/types/**/*.js",
+    "lib/types/**/*.d.ts"
+  ],
+  "license": "MIT",
+  "peerDependencies": {
+    "@stackstackstack/dsh-brand": "^0.1.5",
+    "@stackstackstack/dsh-agent": "^0.1.5",
+    "@stackstackstack/dsh-invariants": "^0.1.5",
+    "@stackstackstack/dsh-llm": "^0.1.5",
+    "@stackstackstack/dsh-timeout": "^0.1.5",
+    "@stackstackstack/dsh-session": "^0.1.5",
+    "@deepseek-ai/cordis": "^4.0.1"
+  },
+  "dependencies": {
+    "@deepseek-ai/schemastery": "^3.18.1"
+  },
+  "devDependencies": {
+    "@stackstackstack/dsh-brand": "^0.1.5",
+    "@deepseek-ai/cordis-plugin-include": "^1.0.6",
+    "@deepseek-ai/cordis-plugin-loader": "^1.0.2",
+    "@stackstackstack/dsh-agent": "^0.1.5",
+    "@stackstackstack/dsh-agent-loop": "^0.1.5",
+    "@stackstackstack/dsh-agent-loop-testkit": "^0.1.5",
+    "@stackstackstack/dsh-invariants": "^0.1.5",
+    "@stackstackstack/dsh-session": "^0.1.5",
+    "@stackstackstack/dsh-llm-deepseek": "^0.1.5",
+    "@stackstackstack/dsh-session-persistence-jsonl": "^0.1.5",
+    "@stackstackstack/dsh-session-persistence-sqlite": "^0.1.5",
+    "@stackstackstack/dsh-llm-mock-server": "^0.1.5",
+    "@stackstackstack/dsh-system-prompt": "^0.1.5",
+    "@stackstackstack/dsh-tools": "^0.1.5",
+    "@stackstackstack/dsh-timeout": "^0.1.5",
+    "@deepseek-ai/cordis": "^4.0.1",
+    "@stackstackstack/dsh-llm": "^0.1.5"
+  }
+}