test: expand sequential response coverage across providers and edge cases (#52)

## Summary

Comprehensive test coverage expansion and two implementation
improvements across the entire llmock codebase.

### Implementation Changes

**Chaos injection feature** — New fault tolerance testing capability:
- `ChaosConfig` with `dropRate`, `malformedRate`, `disconnectRate` (all
0-1 probability)
- Three override levels: server defaults < fixture-level < per-request
headers (`X-LLMock-Chaos-*`)
- All HTTP handlers wired (Chat Completions, Responses, Messages,
Gemini, Bedrock, Embeddings)
- CLI flags: `--chaos-drop`, `--chaos-malformed`, `--chaos-disconnect`
- Journal recording with `chaosAction` field
- `setChaos()`/`clearChaos()` on LLMock class (propagates to running
server)

**Provider-specific error formats** — Previously all providers returned
identical OpenAI-style error JSON. Now:
- Anthropic/Bedrock: `{ type: "error", error: { type, message } }`
- Gemini: `{ error: { code, message, status } }`
- OpenAI: unchanged (already correct)

### Test Coverage (848 → 906 tests, +58)

**Sequential Responses** (+9): error responses, tool calls, gap indices,
Anthropic/Gemini sequences, predicate+sequenceIndex, model matching,
resetMatchCounts, concurrent requests

**Embeddings** (+14): base64 encoding_format, empty input, sequential
embeddings, Unicode, error status codes (401, 503)

**Structured Output** (+9): streaming json_object, json_schema matching,
combined responseFormat+model+userMessage routing, malformed
response_format, sequenceIndex+error interleaving

**Streaming Physics** (+6): streamingProfile+truncateAfterChunks
combined, streamingProfile+disconnectAfterMs, truncateAfterChunks:1
boundary, large chunkSize, empty content streaming, Anthropic truncation

**Chaos** (+12): server-level drop/malformed on
Anthropic/Gemini/Bedrock, fixture-level chaos scoping, journal
recording, setChaos/clearChaos integration

**Error Format** (+6): Anthropic/Gemini/Bedrock format conformance,
streaming error returns JSON not SSE, cross-provider format verification

**Provider Coverage** (+4): Azure streaming, onToolResult live
verification, onToolCall response verification, Groq streaming through
proxy

**Fixtures** (+7): streamingProfile/chaos JSON passthrough, validation
boundary conditions (status 99/100/599), error status default 500

**WebSocket** (+5): concurrent message serialization (no interleaving),
frame fragmentation (continuation frames), multiple tool calls (Realtime
+ Responses WS)

### Bug Fixes Found During Testing
- `setChaos()`/`clearChaos()` silently failed on running servers
(captured snapshot at startup, not live reference)
- Error responses used OpenAI format for all providers (Anthropic,
Gemini, Bedrock now use native formats)

## Test plan

- [x] All 906 tests pass
- [x] Prettier clean
- [x] ESLint clean
- [x] Full build passes
- [x] 7-agent code review loop — zero actionable findings

Author: jpr5

src/__tests__/api-conformance.test.ts

@@ -271,6 +271,54 @@ describe("Azure OpenAI: journal recording", () => {
   });
 });
 
+describe("Azure OpenAI: streaming", () => {
+  it("streaming through Azure deployment path", async () => {
+    const fixtures: Fixture[] = [
+      {
+        match: { userMessage: "stream-test" },
+        response: { content: "Azure streamed!" },
+      },
+    ];
+    instance = await createServer(fixtures);
+
+    const { status, body } = await httpPost(
+      `${instance.url}/openai/deployments/my-gpt4/chat/completions?api-version=2024-02-01`,
+      {
+        model: "gpt-4",
+        stream: true,
+        messages: [{ role: "user", content: "stream-test" }],
+      },
+    );
+
+    expect(status).toBe(200);
+
+    // Parse SSE events
+    const events: unknown[] = [];
+    for (const line of body.split("\n")) {
+      if (line.startsWith("data: ") && line !== "data: [DONE]") {
+        events.push(JSON.parse(line.slice(6)));
+      }
+    }
+
+    expect(events.length).toBeGreaterThanOrEqual(3);
+
+    // All chunks should have chat.completion.chunk object type
+    for (const event of events) {
+      const ev = event as { object: string };
+      expect(ev.object).toBe("chat.completion.chunk");
+    }
+
+    // Content should be present across the chunks
+    const contentParts = events
+      .map((e) => (e as { choices: [{ delta: { content?: string } }] }).choices[0].delta.content)
+      .filter(Boolean);
+    expect(contentParts.join("")).toBe("Azure streamed!");
+
+    // Body ends with [DONE]
+    expect(body).toContain("data: [DONE]");
+  });
+});
+
 describe("Azure OpenAI: 404 when no fixture matches", () => {
   it("returns 404 when no fixture matches the request", async () => {
     const fixtures: Fixture[] = [

src/__tests__/azure.test.ts

@@ -192,6 +192,29 @@ describe("POST /model/{modelId}/invoke (error handling)", () => {
     expect(body.error.message).toBe("Rate limited");
   });
 
+  it("returns error in Anthropic format: { type: 'error', error: { type, message } }", async () => {
+    instance = await createServer(allFixtures);
+    const res = await post(
+      `${instance.url}/model/anthropic.claude-3-5-sonnet-20241022-v2:0/invoke`,
+      {
+        anthropic_version: "bedrock-2023-05-31",
+        max_tokens: 512,
+        messages: [{ role: "user", content: "fail" }],
+      },
+    );
+
+    expect(res.status).toBe(429);
+    const body = JSON.parse(res.body);
+    // Bedrock uses Anthropic Messages format for errors
+    expect(body.type).toBe("error");
+    expect(body.error).toBeDefined();
+    expect(body.error.type).toBe("rate_limit_error");
+    expect(body.error.message).toBe("Rate limited");
+    // Should NOT have OpenAI-style fields
+    expect(body.status).toBeUndefined();
+    expect(body.error.code).toBeUndefined();
+  });
+
   it("returns 404 when no fixture matches", async () => {
     instance = await createServer(allFixtures);
     const res = await post(