@x1a0f3n9/dsh-llm-mock-server 0.1.5-rc.3

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/test-support/llm-mock-server/README.md
+README.md: be311d9c83bcd35ad5bd0c003f6e95861b6d6976
+README.zh.md: 7a022131d9ef09d9ef89c91cae418f093f77aca1

package/README.md

@@ -0,0 +1,170 @@
+---
+description: "Scriptable OpenAI-compatible fault server for testing LLM adapters and recovery policy without a provider key, for test authors and demos."
+kind: "package-library"
+---
+
+# @x1a0f3n9/dsh-llm-mock-server
+
+English | [中文](README.zh.md)
+
+## Summary
+
+This package gives tests and demos a scriptable OpenAI-compatible HTTP/SSE endpoint, so they can exercise model-provider failures and successes without a provider key. Each accepted `/chat/completions` request consumes the next scripted behavior, including resets, stalls, malformed chunks, rate limits, server errors, completions, and tool calls. Test authors can run it with `pnpm run mock:llm` or call `startMockLlmServer`, which returns captured requests for assertions. Seeded `random` behavior supports reproducible mixed-failure stress runs.
+
+## Table of Contents
+
+- [Use this package](#use-this-package)
+- [Understand the implementation](#understand-the-implementation)
+- [Further Exploration](#further-exploration)
+- [Model Experience](#model-experience)
+- [Known Limitations and Deferred Work](#known-limitations-and-deferred-work)
+- [Dev Note](#dev-note)
+
+-----
+
+<a id="use-this-package"></a>
+## Use this package
+
+This package lets a test or demo speak the provider protocol without a provider: start the server, script the wire behaviors you want to exercise, and point a real LLM adapter at its base URL.
+
+### Running it standalone
+
+Run the source entry from this repository:
+
+```sh
+pnpm run mock:llm \
+  --port 8000 \
+  --api-key mock-key \
+  --sequence partial_disconnect,success \
+  --partial-text "discard this half"
+```
+
+Point the shipping DeepSeek adapter at the server; it appends `/chat/completions` to the configured base:
+
+```sh
+DEEPSEEK_BASE_URL=http://127.0.0.1:8000/v1 \
+DEEPSEEK_API_KEY=mock-key \
+pnpm dsh --profile headless "test provider recovery"
+```
+
+The repository script writes JSONL to stdout: a `ready` record carries the `/v1` base URL and random seed, followed by request/result records that name both the scripted behavior and the concrete behavior selected. The package exposes no installable binary.
+
+### Scripting behaviors
+
+`--sequence` is a comma-separated FIFO. Exhaustion returns a structured HTTP 500; `--repeat-last` explicitly reuses the last entry.
+
+| Behavior | Wire result |
+|---|---|
+| `connection_reset` | Destroy the socket before HTTP headers |
+| `stream_disconnect` | Send SSE headers, then reset before the first event |
+| `partial_disconnect` | Send text deltas, then reset the socket |
+| `stall` | Send SSE headers and remain idle until client/server cancellation |
+| `empty` | Send a valid content-less stop and `[DONE]` |
+| `empty_body` / `stream_eof` / `partial_eof` | End cleanly without the required `[DONE]` boundary |
+| `malformed_json` / `malformed_event` | Send invalid SSE JSON or an invalid provider chunk shape |
+| `rate_limit` / `server_error` / `service_unavailable` | Return retry-oriented 429/500/503 JSON errors |
+| `auth_error` / `invalid_request` / `context_overflow` / `quota_exceeded` | Return terminal or separately recovered provider errors |
+| `success` / `slow_success` / `reasoning_success` | Stream a complete text response, optionally delayed or preceded by reasoning |
+| `tool_call_success` / `max_tokens` | Complete with a tool call or `length` finish |
+| `wrong_content_type` | Send a valid SSE body under `application/json` |
+| `random` | Select a concrete request behavior from weighted seeded randomness |
+
+`connection_refused` is CLI-only and must be the first entry. It delays binding a caller-specified nonzero port, so requests during `--listen-delay-ms` receive a real TCP refusal; the remaining entries begin after the listener starts.
+
+### Random mode
+
+Use a repeating `random` entry for an open-ended mixed run:
+
+```sh
+pnpm run mock:llm \
+  --port 8000 \
+  --sequence random \
+  --repeat-last \
+  --seed 42 \
+  --random-weights 'success=60,slow_success=10,connection_reset=5,stream_disconnect=5,partial_disconnect=10,empty=5,server_error=5'
+```
+
+Omitting `--seed` generates one and prints it in the `ready` record. `--random-weights` accepts non-negative relative `behavior=weight` entries and requires at least one positive concrete behavior. The exported default is a success-heavy stress profile containing reset, disconnect, partial output, empty completion, stall, 429/5xx, clean truncation, and malformed JSON; it is test pressure, not an estimate of production incident frequency. `connection_refused` is excluded because a bound request handler cannot produce a true refusal. When random weights include `stall`, configure the client under test with a short stream-idle timeout so the scenario terminates promptly.
+
+### Timing and content controls
+
+The CLI exposes `--success-text`, `--partial-text`, `--reasoning-text`, `--chunk-size`, `--chunk-delay-ms`, `--disconnect-delay-ms`, `--retry-after-ms`, `--request-id`, `--tool-name`, and `--tool-arguments`. Millisecond delays are bounded integers within Node's timer range; `retryAfterMs` must also be positive. The library accepts the same camel-case options. An optional exact `apiKey` validates `Authorization: Bearer <token>`; omission accepts any token.
+
+### What can go wrong
+
+- **The script runs out** — exhaustion returns a structured HTTP 500; set `--repeat-last` or lengthen the sequence when a run needs more requests.
+- **Random weights without a positive concrete behavior are rejected** — every entry must name an existing behavior and at least one must carry positive weight.
+- **Invalid requests do not consume the script** — wrong methods, paths, bearer tokens, and malformed JSON get ordinary 4xx responses, so a misconfigured client can burn retries without advancing the sequence.
+
+-----
+
+<a id="understand-the-implementation"></a>
+## Understand the implementation
+
+<details>
+<summary>Implementation internals — click to expand</summary>
+
+This section explains the design of the server; the observable behavior is fully covered in [Use this package](#use-this-package).
+
+### Design
+
+The server is built on one rule: each accepted chat-completions request consumes exactly one behavior from an arrival-ordered FIFO cursor, and the server never retries or interprets harness policy. Validation happens before the cursor advances — only a `POST` whose path ends in `/chat/completions`, with a valid bearer token when one is configured and a parseable JSON body, consumes the script; everything else receives an ordinary 4xx. `random` entries resolve at request time through a seeded PRNG over the configured weights, so a run is reproducible from its printed seed.
+
+### Source map
+
+| File | Role |
+|---|---|
+| [`src/index.ts`](src/index.ts) | `startMockLlmServer`: listener, behavior table, seeded randomness, telemetry, captured request records |
+| [`src/cli.ts`](src/cli.ts) | `--sequence` and timing/content option parsing, JSONL stdout telemetry |
+| [`src/bin.ts`](src/bin.ts) | The `pnpm run mock:llm` source entry |
+| — | No runtime invariant companion is published; this standalone test server owns no Cordis event stream or shared data; its wire behavior and lifecycle are exercised through direct HTTP and assembled-loop tests. |
+
+### Wire flow
+
+A request enters the handler, is validated, and selects a behavior: a concrete script entry runs directly, `random` draws one, and an exhausted script reports `script_exhausted` as a structured 500. `runBehavior` then executes the wire result — socket destroy, SSE stream, JSON error, or completion — while every request and outcome is recorded in arrival order on the returned handle for test assertions. `close()` stops accepting requests and force-terminates stalled connections.
+
+</details>
+
+-----
+
+<a id="further-exploration"></a>
+## Further Exploration
+
+Read these pages when the package-level contract is not enough. They move from the fault server to the adapter contract it exercises and the keyless alternative for recorded success transcripts.
+
+- [LLM package](../../llm/llm/README.md) — the provider stream contract and retry policy this server exercises.
+- [llm-replay](../llm-replay/README.md) — the keyless counterpart that replays recorded success transcripts instead of faulting.
+- [Testing policy](../../../docs/testing.md) — the coverage tiers and recovery tests this server serves.
+- [Test-support group map](../README.md) — sibling harnesses and support packages.
+
+-----
+
+<a id="model-experience"></a>
+## Model Experience
+
+None, as this test server substitutes provider wire behavior without invoking a real model.
+
+#### KV Cache effect
+
+None; requests terminate locally and never reach a provider cache.
+
+## Known Limitations and Deferred Work
+
+<a id="known-limitations-and-deferred-work"></a>
+
+
+These limits define when the server needs special care. They are current package constraints, not a task backlog.
+
+- **Random weights model test pressure, not production incidence** — callers that want an environment-specific distribution must provide measured weights and record the emitted seed.
+- **Request scripts are arrival-ordered** — concurrent callers share one cursor, so deterministic per-session fault assignment requires separate server instances.
+- **True connection refusal is a listener lifecycle phase** — the CLI delay must overlap the client attempt; request-level random selection can only reset an accepted connection.
+
+<a id="dev-note"></a>
+### Dev Note
+
+<details>
+<summary>Working context for maintainers — click to expand</summary>
+
+None.
+
+</details>

package/README.zh.md

@@ -0,0 +1,170 @@
+---
+description: "用于在无提供方密钥的情况下测试 LLM（大语言模型）适配器与恢复策略的可通过脚本控制的 OpenAI 兼容故障服务器，面向测试作者与演示。"
+kind: "package-library"
+---
+
+# @x1a0f3n9/dsh-llm-mock-server
+
+[English](README.md) | 中文
+
+## 概述
+
+本包为测试与演示提供可编脚本的 OpenAI 兼容 HTTP／SSE（Server-Sent Events）端点，使其无需提供方密钥即可检验模型提供方的失败与成功。每个已接受的 `/chat/completions` 请求依次消费下一个脚本行为，包括重置、停滞、畸形分片、限流、服务器错误、补全与工具调用。测试作者可以通过 `pnpm run mock:llm` 运行服务器，也可以调用 `startMockLlmServer`，后者会返回捕获的请求供断言使用。带种子的 `random` 行为支持可复现的混合故障压力运行。
+
+## 目录
+
+- [使用本包](#use-this-package)
+- [理解实现](#understand-the-implementation)
+- [进一步探索](#further-exploration)
+- [模型体验](#model-experience)
+- [已知限制与延期工作](#known-limitations-and-deferred-work)
+- [开发备注](#dev-note)
+
+-----
+
+<a id="use-this-package"></a>
+## 使用本包
+
+本包让测试或演示无需实际提供方即可使用提供方协议进行通信：启动服务器，脚本化你想检验的协议行为，然后把真实 LLM 适配器指向它的 base URL。
+
+### 独立运行
+
+从本仓库运行源入口：
+
+```sh
+pnpm run mock:llm \
+  --port 8000 \
+  --api-key mock-key \
+  --sequence partial_disconnect,success \
+  --partial-text "discard this half"
+```
+
+将发布的 DeepSeek 适配器指向服务器；它会将 `/chat/completions` 追加到已配置 base：
+
+```sh
+DEEPSEEK_BASE_URL=http://127.0.0.1:8000/v1 \
+DEEPSEEK_API_KEY=mock-key \
+pnpm dsh --profile headless "test provider recovery"
+```
+
+仓库脚本将 JSONL 写入 stdout：`ready` 记录携带以 `/v1` 结尾的 base URL 与随机种子，后续请求/结果记录同时命名脚本行为与实际选中的具体行为。本包不公开可安装的二进制命令。
+
+### 脚本化行为
+
+`--sequence` 是逗号分隔的 FIFO。耗尽时返回结构化 HTTP 500；`--repeat-last` 显式重用最后一项。
+
+| 行为 | 协议结果 |
+|---|---|
+| `connection_reset` | 在发送 HTTP 标头前销毁 socket |
+| `stream_disconnect` | 发送 SSE 标头，然后在第一个事件前重置连接 |
+| `partial_disconnect` | 发送文本增量，然后重置 socket |
+| `stall` | 发送 SSE 标头，并保持空闲，直到客户端／服务器取消 |
+| `empty` | 发送有效的无内容 stop 和 `[DONE]` |
+| `empty_body` / `stream_eof` / `partial_eof` | 正常结束，但缺少必需的 `[DONE]` 边界 |
+| `malformed_json` / `malformed_event` | 发送无效 SSE JSON 或无效提供方分片形态 |
+| `rate_limit` / `server_error` / `service_unavailable` | 返回面向重试的 429/500/503 JSON 错误 |
+| `auth_error` / `invalid_request` / `context_overflow` / `quota_exceeded` | 返回终止性错误或需要单独恢复的提供方错误 |
+| `success` / `slow_success` / `reasoning_success` | 流式发送完整文本响应，可选延迟或先发送推理（reasoning） |
+| `tool_call_success` / `max_tokens` | 以工具调用或结束原因 `length` 完成 |
+| `wrong_content_type` | 以 `application/json` 内容类型发送有效 SSE 正文 |
+| `random` | 按带权重的种子随机选择具体请求行为 |
+
+`connection_refused` 只能在 CLI 中使用，且必须是第一个条目。它会延迟绑定调用方指定的非零端口，因此 `--listen-delay-ms` 期间的请求会收到真实 TCP 拒绝；其余条目在 listener 启动后开始。
+
+### 随机模式
+
+使用重复 `random` 条目执行开放式混合运行：
+
+```sh
+pnpm run mock:llm \
+  --port 8000 \
+  --sequence random \
+  --repeat-last \
+  --seed 42 \
+  --random-weights 'success=60,slow_success=10,connection_reset=5,stream_disconnect=5,partial_disconnect=10,empty=5,server_error=5'
+```
+
+省略 `--seed` 会生成种子，并在 `ready` 记录中打印。`--random-weights` 接受非负的相对 `behavior=weight` 条目，并要求至少一个正权重具体行为。导出默认值是一个成功占主导的压力分布，包含 reset、disconnect、部分输出、空完成、stall、429/5xx、干净截断与格式错误的 JSON；它用于施加测试压力，而非估计生产事故频率。`connection_refused` 被排除，因为已绑定的请求处理器无法产生真实拒绝。随机权重包含 `stall` 时，为待测客户端配置较短的流空闲超时，使场景及时结束。
+
+### 时序与内容控制
+
+CLI 公开 `--success-text`、`--partial-text`、`--reasoning-text`、`--chunk-size`、`--chunk-delay-ms`、`--disconnect-delay-ms`、`--retry-after-ms`、`--request-id`、`--tool-name` 与 `--tool-arguments`。毫秒延迟是 Node 定时器范围内的有界整数；`retryAfterMs` 还必须为正数。库接受相同的 camel-case 选项。可选的 `apiKey` 会精确验证 `Authorization: Bearer <token>`；省略时接受任何 token。
+
+### 可能出什么问题
+
+- **脚本耗尽**——耗尽时返回结构化 HTTP 500；当一次运行需要更多请求时设置 `--repeat-last` 或加长序列。
+- **没有正权重具体行为的随机权重会被拒绝**——每个条目都必须命名现有行为，且至少一个条目带正权重。
+- **无效请求不消费脚本**——错误方法、路径、Bearer token 与畸形 JSON 会收到普通 4xx 响应，因此配置错误的客户端可能耗尽重试却不推进序列。
+
+-----
+
+<a id="understand-the-implementation"></a>
+## 理解实现
+
+<details>
+<summary>实现细节——点击展开</summary>
+
+本节解释服务器的设计；可观察行为已在[使用本包](#use-this-package)中完整说明。
+
+### 设计
+
+服务器建立在一个规则之上：每个已接受的 chat-completions 请求从按到达顺序排列的 FIFO 游标消费恰好一个行为，服务器从不重试或解读 harness 策略。校验先于游标推进——只有 `POST` 且路径以 `/chat/completions` 结尾、配置密钥时携带有效 Bearer token、且 JSON 正文可解析的请求才消费脚本；其余请求都收到普通 4xx。`random` 条目在请求时通过带种子的 PRNG 按配置权重解析，因此一次运行可由其打印出的种子复现。
+
+### 源码地图
+
+| 文件 | 职责 |
+|---|---|
+| [`src/index.ts`](src/index.ts) | `startMockLlmServer`：listener、行为表、种子随机、遥测（telemetry）、捕获的请求记录 |
+| [`src/cli.ts`](src/cli.ts) | `--sequence` 与时序/内容选项解析、JSONL stdout 遥测 |
+| [`src/bin.ts`](src/bin.ts) | `pnpm run mock:llm` 源入口 |
+| — | 不发布运行时不变式伴生组件；该独立测试服务器不拥有 Cordis 事件流或共享数据；其协议行为和生命周期通过直接 HTTP 测试及组装后的循环测试进行检验。 |
+
+### 协议流程
+
+请求进入处理器、通过校验，然后选择行为：具体脚本条目直接运行，`random` 抽取一个，已耗尽脚本则以结构化 500 报告 `script_exhausted`。随后 `runBehavior` 执行协议结果——销毁 socket、SSE 流、JSON 错误或补全——同时每个请求与结果按到达顺序记录到返回的句柄上，供测试断言。`close()` 停止接受请求并强制终止停滞连接。
+
+</details>
+
+-----
+
+<a id="further-exploration"></a>
+## 进一步探索
+
+当包级约定不够用时阅读以下页面。它们从故障服务器逐步进入它所检验的适配器约定，以及用于已记录成功 transcript（文本记录）的无密钥替代方案。
+
+- [LLM 包](../../llm/llm/README.zh.md)——本服务器所检验的提供方流约定与重试策略。
+- [llm-replay](../llm-replay/README.zh.md)——回放已记录成功 transcript 而非制造故障的无密钥替代方案。
+- [测试策略](../../../docs/testing.zh.md)——本服务器服务的覆盖层级与恢复测试。
+- [test-support 组地图](../README.zh.md)——兄弟 harness 与支持包。
+
+-----
+
+<a id="model-experience"></a>
+## 模型体验
+
+无。该测试服务器替代提供方协议行为，而不调用真实模型。
+
+#### KV Cache 影响
+
+无；请求在本地终止，绝不会到达提供方缓存。
+
+## 已知限制与延期工作
+
+<a id="known-limitations-and-deferred-work"></a>
+
+
+这些限制说明何时需要对该服务器特别小心。它们是当前包约束，不是任务积压。
+
+- **随机权重建模测试压力，而非生产事故频率**——需要环境专用分布的调用方必须提供已测量权重，并记录发出的种子。
+- **请求脚本按到达顺序执行**——并发调用方共享一个游标，因此确定性的每会话故障分配需要独立服务器实例。
+- **真实连接拒绝发生在监听器生命周期阶段**——CLI 延迟必须与客户端尝试重叠；请求级随机选择只能重置已接受的连接。
+
+<a id="dev-note"></a>
+### 开发备注
+
+<details>
+<summary>维护者的工作上下文——点击展开</summary>
+
+无。
+
+</details>

package/lib/index.js

@@ -0,0 +1,520 @@
+import { createServer } from "node:http";
+import { randomBytes } from "node:crypto";
+import { isIP } from "node:net";
+import { setTimeout } from "node:timers/promises";
+//#region lib/types/index.js
+/**
+* Scriptable OpenAI-compatible HTTP/SSE server for transport, protocol, and
+* semantic-empty LLM recovery tests. Each accepted chat-completions request
+* consumes one behavior; the server never retries or interprets harness policy.
+*
+* @module @x1a0f3n9/dsh-llm-mock-server
+*/
+/** Request-scoped behaviors accepted by {@link startMockLlmServer}. */
+const MOCK_LLM_BEHAVIORS = [
+	"connection_reset",
+	"stream_disconnect",
+	"empty",
+	"empty_body",
+	"stream_eof",
+	"partial_eof",
+	"partial_disconnect",
+	"stall",
+	"malformed_json",
+	"malformed_event",
+	"wrong_content_type",
+	"rate_limit",
+	"server_error",
+	"service_unavailable",
+	"auth_error",
+	"invalid_request",
+	"context_overflow",
+	"quota_exceeded",
+	"success",
+	"reasoning_success",
+	"tool_call_success",
+	"max_tokens",
+	"slow_success",
+	"random"
+];
+/**
+* Default stress profile for `random`. Weights are configurable test pressure,
+* not a claim about production incident frequency.
+*/
+const DEFAULT_MOCK_LLM_RANDOM_WEIGHTS = Object.freeze({
+	success: 48,
+	slow_success: 10,
+	max_tokens: 2,
+	connection_reset: 5,
+	stream_disconnect: 5,
+	partial_disconnect: 10,
+	empty: 5,
+	stall: 2,
+	rate_limit: 5,
+	server_error: 4,
+	service_unavailable: 2,
+	partial_eof: 1,
+	malformed_json: 1
+});
+/** Largest millisecond delay accepted by Node timers without truncation. */
+const MAX_MOCK_LLM_TIMER_DELAY_MS = 2147483647;
+const DEFAULT_SUCCESS_TEXT = "mock response recovered";
+const DEFAULT_PARTIAL_TEXT = "discarded partial response";
+const DEFAULT_REASONING_TEXT = "mock reasoning";
+const CONCRETE_BEHAVIORS = new Set(MOCK_LLM_BEHAVIORS.filter((behavior) => behavior !== "random"));
+function boundedInteger(name, value, min, max) {
+	if (!Number.isInteger(value) || value < min || value > max) throw new Error(`llm-mock-server: ${name} must be an integer between ${min} and ${max}`);
+	return value;
+}
+function resolveOptions(options) {
+	const host = options.host ?? "127.0.0.1";
+	const port = boundedInteger("port", options.port ?? 0, 0, 65535);
+	const chunkSize = boundedInteger("chunkSize", options.chunkSize ?? 8, 1, Number.MAX_SAFE_INTEGER);
+	const chunkDelayMs = boundedInteger("chunkDelayMs", options.chunkDelayMs ?? 25, 0, MAX_MOCK_LLM_TIMER_DELAY_MS);
+	const disconnectDelayMs = boundedInteger("disconnectDelayMs", options.disconnectDelayMs ?? 10, 0, MAX_MOCK_LLM_TIMER_DELAY_MS);
+	const retryAfterMs = boundedInteger("retryAfterMs", options.retryAfterMs ?? 1e3, 1, MAX_MOCK_LLM_TIMER_DELAY_MS);
+	const randomSeed = boundedInteger("randomSeed", options.randomSeed ?? randomBytes(4).readUInt32LE(0), 0, 4294967295);
+	const successText = options.successText ?? DEFAULT_SUCCESS_TEXT;
+	const partialText = options.partialText ?? DEFAULT_PARTIAL_TEXT;
+	const reasoningText = options.reasoningText ?? DEFAULT_REASONING_TEXT;
+	const toolName = options.toolName ?? "mock_tool";
+	const toolArguments = options.toolArguments ?? "{\"value\":\"mock\"}";
+	if (host.length === 0) throw new Error("llm-mock-server: host must not be empty");
+	if (options.sequence.length === 0) throw new Error("llm-mock-server: sequence must not be empty");
+	const lastBehavior = options.sequence.reduce((_previous, behavior) => behavior);
+	if (options.apiKey === "") throw new Error("llm-mock-server: apiKey must not be empty");
+	if (successText.length === 0) throw new Error("llm-mock-server: successText must not be empty");
+	if (partialText.length === 0) throw new Error("llm-mock-server: partialText must not be empty");
+	if (reasoningText.length === 0) throw new Error("llm-mock-server: reasoningText must not be empty");
+	if (toolName.length === 0) throw new Error("llm-mock-server: toolName must not be empty");
+	if (options.requestId === "") throw new Error("llm-mock-server: requestId must not be empty");
+	try {
+		JSON.parse(toolArguments);
+	} catch {
+		throw new Error("llm-mock-server: toolArguments must be valid JSON");
+	}
+	const configuredWeights = options.randomWeights ?? DEFAULT_MOCK_LLM_RANDOM_WEIGHTS;
+	const randomWeights = [];
+	for (const [behavior, weight] of Object.entries(configuredWeights)) {
+		if (!CONCRETE_BEHAVIORS.has(behavior)) throw new Error(`llm-mock-server: randomWeights contains unknown concrete behavior ${JSON.stringify(behavior)}`);
+		if (!Number.isFinite(weight) || weight < 0) throw new Error(`llm-mock-server: random weight for ${behavior} must be a non-negative finite number`);
+		if (weight > 0) randomWeights.push([behavior, weight]);
+	}
+	if (randomWeights.length === 0) throw new Error("llm-mock-server: randomWeights must contain at least one positive weight");
+	return {
+		host,
+		port,
+		...options.apiKey === void 0 ? {} : { apiKey: options.apiKey },
+		sequence: [...options.sequence],
+		lastBehavior,
+		repeatLast: options.repeatLast ?? false,
+		randomSeed,
+		randomWeights,
+		successText,
+		partialText,
+		reasoningText,
+		chunkSize,
+		chunkDelayMs,
+		disconnectDelayMs,
+		retryAfterMs,
+		...options.requestId === void 0 ? {} : { requestId: options.requestId },
+		toolName,
+		toolArguments,
+		...options.onEvent === void 0 ? {} : { onEvent: options.onEvent }
+	};
+}
+function emit(options, event) {
+	try {
+		options.onEvent?.(Object.freeze(event));
+	} catch (_telemetryObserverFailure) {}
+}
+async function readJsonBody(request) {
+	const chunks = [];
+	for await (const chunk of request) chunks.push(Buffer.from(chunk));
+	const body = Buffer.concat(chunks).toString("utf8");
+	return body.length === 0 ? void 0 : JSON.parse(body);
+}
+function splitText(text, size) {
+	const points = Array.from(text);
+	const chunks = [];
+	for (let index = 0; index < points.length; index += size) chunks.push(points.slice(index, index + size).join(""));
+	return chunks;
+}
+function openSse(response, contentType = "text/event-stream; charset=utf-8") {
+	response.writeHead(200, {
+		"content-type": contentType,
+		"cache-control": "no-cache",
+		"connection": "keep-alive"
+	});
+	response.flushHeaders();
+}
+function writeSse(record, response, payload) {
+	response.write(`data: ${typeof payload === "string" ? payload : JSON.stringify(payload)}\n\n`);
+	record.chunksSent += 1;
+}
+function writeDone(record, response) {
+	writeSse(record, response, "[DONE]");
+}
+function finishRecord(options, record, outcome) {
+	if (record.outcome !== void 0) return;
+	record.outcome = outcome;
+	emit(options, {
+		type: "result",
+		attempt: record.attempt,
+		scriptBehavior: record.scriptBehavior,
+		behavior: record.behavior,
+		outcome,
+		chunksSent: record.chunksSent
+	});
+}
+function httpError(options, record, response, status, message, code, type = "mock_error") {
+	const headers = { "content-type": "application/json" };
+	if (record.behavior === "rate_limit") headers["retry-after"] = String(Math.ceil(options.retryAfterMs / 1e3));
+	if (options.requestId !== void 0) headers["x-request-id"] = options.requestId;
+	response.writeHead(status, headers);
+	response.end(JSON.stringify({ error: {
+		message,
+		type,
+		code
+	} }));
+	finishRecord(options, record, "completed");
+}
+function terminalChunk(reason, outputTokens) {
+	return {
+		choices: [{
+			index: 0,
+			delta: { content: "" },
+			finish_reason: reason
+		}],
+		usage: {
+			prompt_tokens: 3,
+			completion_tokens: outputTokens
+		}
+	};
+}
+async function pause(milliseconds, response) {
+	if (milliseconds === 0) return !response.destroyed;
+	const controller = new AbortController();
+	const stop = () => {
+		controller.abort();
+	};
+	response.once("close", stop);
+	try {
+		await setTimeout(milliseconds, void 0, { signal: controller.signal });
+		return true;
+	} catch (_responseClosed) {
+		return false;
+	} finally {
+		response.off("close", stop);
+	}
+}
+async function streamText(options, record, response, text, delayMs) {
+	for (const chunk of splitText(text, options.chunkSize)) {
+		writeSse(record, response, { choices: [{
+			index: 0,
+			delta: { content: chunk },
+			finish_reason: null
+		}] });
+		if (!await pause(delayMs, response)) return false;
+	}
+	return true;
+}
+async function completeText(options, record, response, reason, delayMs) {
+	if (!await streamText(options, record, response, options.successText, delayMs)) {
+		finishRecord(options, record, "client_closed");
+		return;
+	}
+	writeSse(record, response, terminalChunk(reason, Array.from(options.successText).length));
+	writeDone(record, response);
+	response.end();
+	finishRecord(options, record, "completed");
+}
+async function disconnect(options, record, response) {
+	if (!await pause(options.disconnectDelayMs, response)) {
+		finishRecord(options, record, "client_closed");
+		return;
+	}
+	finishRecord(options, record, "reset");
+	response.destroy();
+}
+function toolCallChunks(options) {
+	const midpoint = Math.max(1, Math.floor(options.toolArguments.length / 2));
+	return [{ choices: [{
+		index: 0,
+		delta: { tool_calls: [{
+			index: 0,
+			id: "mock-call-1",
+			type: "function",
+			function: {
+				name: options.toolName,
+				arguments: options.toolArguments.slice(0, midpoint)
+			}
+		}] },
+		finish_reason: null
+	}] }, { choices: [{
+		index: 0,
+		delta: { tool_calls: [{
+			index: 0,
+			function: { arguments: options.toolArguments.slice(midpoint) }
+		}] },
+		finish_reason: null
+	}] }];
+}
+async function runBehavior(options, record, request, response) {
+	switch (record.behavior) {
+		case "script_exhausted":
+			httpError(options, record, response, 500, "mock script exhausted", "MOCK_SCRIPT_EXHAUSTED");
+			return;
+		case "connection_reset":
+			finishRecord(options, record, "reset");
+			request.socket.destroy();
+			return;
+		case "stream_disconnect":
+			openSse(response);
+			await disconnect(options, record, response);
+			return;
+		case "empty":
+			openSse(response);
+			writeSse(record, response, terminalChunk("stop", 0));
+			writeDone(record, response);
+			response.end();
+			finishRecord(options, record, "completed");
+			return;
+		case "empty_body":
+			openSse(response);
+			response.end();
+			finishRecord(options, record, "completed");
+			return;
+		case "stream_eof":
+			openSse(response);
+			writeSse(record, response, { choices: [{
+				index: 0,
+				delta: { role: "assistant" },
+				finish_reason: null
+			}] });
+			response.end();
+			finishRecord(options, record, "completed");
+			return;
+		case "partial_eof":
+			openSse(response);
+			await streamText(options, record, response, options.partialText, 0);
+			response.end();
+			finishRecord(options, record, "completed");
+			return;
+		case "partial_disconnect":
+			openSse(response);
+			if (!await streamText(options, record, response, options.partialText, options.chunkDelayMs)) return;
+			await disconnect(options, record, response);
+			return;
+		case "stall":
+			openSse(response);
+			finishRecord(options, record, "stalled");
+			return;
+		case "malformed_json":
+			openSse(response);
+			writeSse(record, response, "{not-json");
+			writeDone(record, response);
+			response.end();
+			finishRecord(options, record, "completed");
+			return;
+		case "malformed_event":
+			openSse(response);
+			writeSse(record, response, { choices: [null] });
+			writeDone(record, response);
+			response.end();
+			finishRecord(options, record, "completed");
+			return;
+		case "wrong_content_type":
+			openSse(response, "application/json");
+			await completeText(options, record, response, "stop", 0);
+			return;
+		case "rate_limit":
+			httpError(options, record, response, 429, "mock rate limit", "rate_limit");
+			return;
+		case "server_error":
+			httpError(options, record, response, 500, "mock server error", "server_error");
+			return;
+		case "service_unavailable":
+			httpError(options, record, response, 503, "mock service unavailable", "service_unavailable");
+			return;
+		case "auth_error":
+			httpError(options, record, response, 401, "mock authentication failed", "invalid_api_key");
+			return;
+		case "invalid_request":
+			httpError(options, record, response, 400, "mock invalid request", "invalid_request");
+			return;
+		case "context_overflow":
+			httpError(options, record, response, 400, "mock input exceeds the model context window", "context_length_exceeded", "invalid_request_error");
+			return;
+		case "quota_exceeded":
+			httpError(options, record, response, 429, "mock insufficient quota", "insufficient_quota");
+			return;
+		case "success":
+			openSse(response);
+			await completeText(options, record, response, "stop", 0);
+			return;
+		case "reasoning_success":
+			openSse(response);
+			for (const chunk of splitText(options.reasoningText, options.chunkSize)) writeSse(record, response, { choices: [{
+				index: 0,
+				delta: { reasoning_content: chunk },
+				finish_reason: null
+			}] });
+			await completeText(options, record, response, "stop", 0);
+			return;
+		case "tool_call_success":
+			openSse(response);
+			for (const chunk of toolCallChunks(options)) writeSse(record, response, chunk);
+			writeSse(record, response, terminalChunk("tool_calls", 2));
+			writeDone(record, response);
+			response.end();
+			finishRecord(options, record, "completed");
+			return;
+		case "max_tokens":
+			openSse(response);
+			await completeText(options, record, response, "length", 0);
+			return;
+		case "slow_success":
+			openSse(response);
+			await completeText(options, record, response, "stop", options.chunkDelayMs);
+			return;
+	}
+}
+function seededRandom(seed) {
+	let state = seed;
+	return () => {
+		state = state + 1831565813 >>> 0;
+		let mixed = state;
+		mixed = Math.imul(mixed ^ mixed >>> 15, mixed | 1);
+		mixed ^= mixed + Math.imul(mixed ^ mixed >>> 7, mixed | 61);
+		return ((mixed ^ mixed >>> 14) >>> 0) / 4294967296;
+	};
+}
+function chooseRandomBehavior(weights, random) {
+	const total = weights.reduce((sum, entry) => sum + entry[1], 0);
+	let draw = random() * total;
+	for (const [behavior, weight] of weights) {
+		if (draw < weight) return behavior;
+		draw -= weight;
+	}
+	/* v8 ignore next -- seededRandom is strictly less than one; this guards floating-point residue only */
+	return weights.at(-1)[0];
+}
+/**
+* Start a local chat-completions server that consumes one configured behavior
+* per accepted request. Only a `POST` path ending in `/chat/completions` consumes the script;
+* invalid routes, methods, authorization, and JSON receive ordinary 4xx
+* responses. Closing the handle terminates stalled connections.
+*
+* @param options - listener, script, response content, timing, and telemetry options.
+* @returns the listening handle after the port is bound.
+*/
+async function startMockLlmServer(options) {
+	const resolved = resolveOptions(options);
+	const requests = [];
+	const random = seededRandom(resolved.randomSeed);
+	let cursor = 0;
+	const selectBehavior = () => {
+		const selected = resolved.sequence[cursor];
+		cursor += 1;
+		const scriptBehavior = selected ?? (resolved.repeatLast ? resolved.lastBehavior : "script_exhausted");
+		return {
+			scriptBehavior,
+			behavior: scriptBehavior === "random" ? chooseRandomBehavior(resolved.randomWeights, random) : scriptBehavior
+		};
+	};
+	const handle = async (request, response) => {
+		/* v8 ignore next -- node:http server requests always carry a URL despite the shared optional type */
+		const path = new URL(request.url ?? "/", "http://mock.invalid").pathname;
+		if (request.method !== "POST") {
+			response.writeHead(405, { allow: "POST" }).end();
+			return;
+		}
+		if (!path.endsWith("/chat/completions")) {
+			response.writeHead(404).end();
+			return;
+		}
+		if (resolved.apiKey !== void 0 && request.headers.authorization !== `Bearer ${resolved.apiKey}`) {
+			response.writeHead(401, { "content-type": "application/json" });
+			response.end(JSON.stringify({ error: {
+				message: "invalid mock bearer token",
+				code: "invalid_api_key"
+			} }));
+			return;
+		}
+		let body;
+		try {
+			body = await readJsonBody(request);
+		} catch {
+			response.writeHead(400, { "content-type": "application/json" });
+			response.end(JSON.stringify({ error: {
+				message: "request body must be valid JSON",
+				code: "invalid_json"
+			} }));
+			return;
+		}
+		const selected = selectBehavior();
+		const record = {
+			attempt: requests.length + 1,
+			scriptBehavior: selected.scriptBehavior,
+			behavior: selected.behavior,
+			path,
+			headers: { ...request.headers },
+			body,
+			chunksSent: 0
+		};
+		requests.push(record);
+		response.once("close", () => {
+			if (!response.writableFinished && record.outcome === void 0) finishRecord(resolved, record, "client_closed");
+		});
+		emit(resolved, {
+			type: "request",
+			attempt: record.attempt,
+			scriptBehavior: record.scriptBehavior,
+			behavior: record.behavior,
+			path
+		});
+		await runBehavior(resolved, record, request, response);
+	};
+	const server = createServer((request, response) => {
+		/* v8 ignore start -- last-resort containment for Node response failures after validated test inputs */
+		handle(request, response).catch((error) => {
+			const record = requests.at(-1);
+			if (record !== void 0) finishRecord(resolved, record, "server_error");
+			if (response.headersSent) {
+				response.destroy(error instanceof Error ? error : new Error(String(error)));
+				return;
+			}
+			response.writeHead(500, { "content-type": "application/json" });
+			response.end(JSON.stringify({ error: {
+				message: "mock server handler failed",
+				code: "MOCK_HANDLER_FAILED"
+			} }));
+		});
+		/* v8 ignore stop */
+	});
+	let closing;
+	const close = () => closing ??= new Promise((resolveClose) => {
+		server.close(() => {
+			resolveClose();
+		});
+		server.closeAllConnections();
+	});
+	await new Promise((resolveListen, rejectListen) => {
+		server.once("error", rejectListen);
+		server.listen(resolved.port, resolved.host, () => {
+			server.off("error", rejectListen);
+			resolveListen();
+		});
+	});
+	const address = server.address();
+	return {
+		baseURL: `http://${isIP(resolved.host) === 6 ? `[${resolved.host}]` : resolved.host}:${address.port}`,
+		port: address.port,
+		randomSeed: resolved.randomSeed,
+		requests,
+		close
+	};
+}
+//#endregion
+export { DEFAULT_MOCK_LLM_RANDOM_WEIGHTS, MAX_MOCK_LLM_TIMER_DELAY_MS, MOCK_LLM_BEHAVIORS, startMockLlmServer };

package/lib/types/bin.d.ts

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+/**
+ * Standalone process wrapper for the scriptable mock LLM server.
+ * @module @x1a0f3n9/dsh-llm-mock-server/src/bin
+ */
+export {};
+//# sourceMappingURL=bin.d.ts.map

package/lib/types/cli.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Dependency-free CLI parsing for the standalone mock LLM server.
+ * @module @x1a0f3n9/dsh-llm-mock-server/cli
+ */
+import type { MockLlmServerOptions } from './index.ts';
+/** Listener lifecycle behavior understood only by the standalone CLI. */
+export declare const CONNECTION_REFUSED_BEHAVIOR = "connection_refused";
+/** Parsed CLI configuration, including a pre-listen unavailable interval. */
+export interface MockLlmCliConfig {
+    /** Server options after removing the lifecycle-only `connection_refused` entry. */
+    readonly server: MockLlmServerOptions;
+    /** Delay before binding the model port; an integer from zero through the Node timer maximum. */
+    readonly listenDelayMs: number;
+    /** Whether the original sequence requested a true pre-listen refusal phase. */
+    readonly startsUnavailable: boolean;
+}
+/** Result of parsing `dsh-llm-mock-server` arguments. */
+export type MockLlmCliParseResult = {
+    readonly kind: 'help';
+} | {
+    readonly kind: 'run';
+    readonly config: MockLlmCliConfig;
+};
+/** Command usage written for `--help` and invalid arguments. */
+export declare const MOCK_LLM_CLI_USAGE = "Usage: dsh-llm-mock-server [options]\n\nRequired:\n  --sequence <a,b,...>       Ordered behaviors; connection_refused is allowed first\n\nListener:\n  --host <host>              Default 127.0.0.1\n  --port <port>              Default 8000; required and nonzero for connection_refused\n  --api-key <token>          Validate exact Bearer token when present\n  --listen-delay-ms <ms>     Unavailable interval (default 750 with connection_refused)\n  --repeat-last              Repeat the final request behavior after exhaustion\n  --seed <uint32>            Reproduce random selections\n  --random-weights <a=n,...> Relative weights for concrete behaviors\n\nResponse:\n  --success-text <text>\n  --partial-text <text>\n  --reasoning-text <text>\n  --chunk-size <count>\n  --chunk-delay-ms <ms>\n  --disconnect-delay-ms <ms>\n  --retry-after-ms <ms>\n  --request-id <id>\n  --tool-name <name>\n  --tool-arguments <json>\n\nOther:\n  --help\n";
+/**
+ * Parse standalone server arguments without starting a process or listener.
+ * Tokenizing rides `node:util` `parseArgs` (strict, no positionals); numeric
+ * coercion, bounds, and cross-option constraints remain manual below it.
+ * @param argv - arguments after the executable name.
+ * @returns help or validated run configuration.
+ */
+export declare function parseMockLlmCliArgs(argv: readonly string[]): MockLlmCliParseResult;
+//# sourceMappingURL=cli.d.ts.map

package/lib/types/index.d.ts

@@ -0,0 +1,122 @@
+/**
+ * Scriptable OpenAI-compatible HTTP/SSE server for transport, protocol, and
+ * semantic-empty LLM recovery tests. Each accepted chat-completions request
+ * consumes one behavior; the server never retries or interprets harness policy.
+ *
+ * @module @x1a0f3n9/dsh-llm-mock-server
+ */
+import type { IncomingHttpHeaders } from 'node:http';
+/** Request-scoped behaviors accepted by {@link startMockLlmServer}. */
+export declare const MOCK_LLM_BEHAVIORS: readonly ["connection_reset", "stream_disconnect", "empty", "empty_body", "stream_eof", "partial_eof", "partial_disconnect", "stall", "malformed_json", "malformed_event", "wrong_content_type", "rate_limit", "server_error", "service_unavailable", "auth_error", "invalid_request", "context_overflow", "quota_exceeded", "success", "reasoning_success", "tool_call_success", "max_tokens", "slow_success", "random"];
+/** One scripted mock behavior name; `random` selects a concrete behavior per request. */
+export type MockLlmBehavior = typeof MOCK_LLM_BEHAVIORS[number];
+/** One concrete request behavior after resolving a `random` script entry. */
+export type ConcreteMockLlmBehavior = Exclude<MockLlmBehavior, 'random'>;
+/** Relative non-negative weights for random request behavior selection. */
+export type MockLlmRandomWeights = Partial<Record<ConcreteMockLlmBehavior, number>>;
+/**
+ * Default stress profile for `random`. Weights are configurable test pressure,
+ * not a claim about production incident frequency.
+ */
+export declare const DEFAULT_MOCK_LLM_RANDOM_WEIGHTS: Readonly<MockLlmRandomWeights>;
+/** Largest millisecond delay accepted by Node timers without truncation. */
+export declare const MAX_MOCK_LLM_TIMER_DELAY_MS = 2147483647;
+/** How one accepted request ended at the mock boundary. */
+export type MockLlmRequestOutcome = 'completed' | 'reset' | 'stalled' | 'client_closed' | 'server_error';
+/** Immutable telemetry emitted when a request starts or reaches an outcome. */
+export type MockLlmServerEvent = {
+    readonly type: 'request';
+    readonly attempt: number;
+    readonly scriptBehavior: MockLlmBehavior | 'script_exhausted';
+    readonly behavior: ConcreteMockLlmBehavior | 'script_exhausted';
+    readonly path: string;
+} | {
+    readonly type: 'result';
+    readonly attempt: number;
+    readonly scriptBehavior: MockLlmBehavior | 'script_exhausted';
+    readonly behavior: ConcreteMockLlmBehavior | 'script_exhausted';
+    readonly outcome: MockLlmRequestOutcome;
+    readonly chunksSent: number;
+};
+/** Captured wire request and its final server-side outcome. */
+export interface MockLlmRequestRecord {
+    /** One-based accepted chat-completions request number. */
+    readonly attempt: number;
+    /** Script entry consumed for this request before random resolution. */
+    readonly scriptBehavior: MockLlmBehavior | 'script_exhausted';
+    /** Concrete behavior selected for this request, or exhaustion after the configured script. */
+    readonly behavior: ConcreteMockLlmBehavior | 'script_exhausted';
+    /** Original request path, including a `/v1` prefix when the client supplied one. */
+    readonly path: string;
+    /** Detached request headers. */
+    readonly headers: Readonly<IncomingHttpHeaders>;
+    /** Parsed JSON request body. */
+    readonly body: unknown;
+    /** Number of SSE `data:` events handed to Node before the outcome. */
+    chunksSent: number;
+    /** Final server-side outcome; absent while a stalled request remains open. */
+    outcome?: MockLlmRequestOutcome;
+}
+/** Configuration for one mock server instance. */
+export interface MockLlmServerOptions {
+    /** Loopback host by default. */
+    readonly host?: string;
+    /** TCP port; zero requests an OS-assigned port. */
+    readonly port?: number;
+    /** Optional exact bearer token; omission accepts any authorization header. */
+    readonly apiKey?: string;
+    /** Ordered request behaviors; exhaustion fails loud unless `repeatLast` is true. */
+    readonly sequence: readonly MockLlmBehavior[];
+    /** Reuse the final behavior after the sequence is consumed. */
+    readonly repeatLast?: boolean;
+    /** Optional deterministic unsigned 32-bit seed; omission generates and exposes one. */
+    readonly randomSeed?: number;
+    /** Relative weights used whenever a script entry is `random`. */
+    readonly randomWeights?: Readonly<MockLlmRandomWeights>;
+    /** Complete text returned by success-shaped behaviors. */
+    readonly successText?: string;
+    /** Text emitted before partial EOF/reset behaviors terminate. */
+    readonly partialText?: string;
+    /** Reasoning text emitted by `reasoning_success`. */
+    readonly reasoningText?: string;
+    /** Unicode code-point count per text or reasoning SSE delta. */
+    readonly chunkSize?: number;
+    /** Inter-chunk delay for `slow_success`, in milliseconds. */
+    readonly chunkDelayMs?: number;
+    /** Delay after headers/deltas before a forced disconnect, in milliseconds. */
+    readonly disconnectDelayMs?: number;
+    /** Provider retry delay; the wire `Retry-After` value rounds up to whole seconds. */
+    readonly retryAfterMs?: number;
+    /** Optional provider request id returned on HTTP failures. */
+    readonly requestId?: string;
+    /** Tool name emitted by `tool_call_success`. */
+    readonly toolName?: string;
+    /** Raw JSON arguments emitted by `tool_call_success`. */
+    readonly toolArguments?: string;
+    /** Optional observer for JSONL CLI telemetry; observer failures never affect wire behavior. */
+    readonly onEvent?: (event: MockLlmServerEvent) => void;
+}
+/** Running mock server and captured request state. */
+export interface MockLlmServer {
+    /** Base URL without `/v1`; both root and `/v1` chat-completions paths are accepted. */
+    readonly baseURL: string;
+    /** Actual bound port, including an OS-assigned value. */
+    readonly port: number;
+    /** Seed used for random behavior selection, including the generated default. */
+    readonly randomSeed: number;
+    /** Live request records in arrival order. */
+    readonly requests: readonly MockLlmRequestRecord[];
+    /** Stop accepting requests and force-close stalled/streaming connections; idempotent. */
+    close(): Promise<void>;
+}
+/**
+ * Start a local chat-completions server that consumes one configured behavior
+ * per accepted request. Only a `POST` path ending in `/chat/completions` consumes the script;
+ * invalid routes, methods, authorization, and JSON receive ordinary 4xx
+ * responses. Closing the handle terminates stalled connections.
+ *
+ * @param options - listener, script, response content, timing, and telemetry options.
+ * @returns the listening handle after the port is bound.
+ */
+export declare function startMockLlmServer(options: MockLlmServerOptions): Promise<MockLlmServer>;
+//# sourceMappingURL=index.d.ts.map

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@x1a0f3n9/dsh-llm-mock-server",
+  "description": "Scriptable OpenAI-compatible HTTP/SSE fault server for LLM recovery tests",
+  "version": "0.1.5-rc.3",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/deepseek-ai/deepseek-harness.git",
+    "directory": "packages/test-support/llm-mock-server"
+  },
+  "type": "module",
+  "main": "lib/index.js",
+  "types": "lib/types/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./lib/types/index.d.ts",
+      "default": "./lib/index.js"
+    },
+    "./src/*": "./src/*",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "lib/index.js",
+    "lib/types/**/*.d.ts"
+  ],
+  "license": "MIT",
+  "peerDependencies": {
+    "@deepseek-ai/cordis": "^4.0.2"
+  },
+  "devDependencies": {
+    "@deepseek-ai/cordis": "^4.0.2"
+  }
+}