@chatman-media/kb 1.5.0 → 1.6.0

package/dist/answer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"answer.d.ts","sourceRoot":"","sources":["../src/answer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAC7B,OAAO,EACL,KAAK,WAAW,EAChB,KAAK,YAAY,EAGjB,KAAK,OAAO,EACb,MAAM,mBAAmB,CAAC;AAC3B,OAAO,KAAK,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAC;AA8BzE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAG9C,OAAO,EACL,KAAK,WAAW,EAChB,KAAK,YAAY,EACjB,KAAK,eAAe,EACpB,iBAAiB,EACjB,KAAK,OAAO,GACb,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EACL,gBAAgB,EAChB,qBAAqB,EACrB,sBAAsB,EACtB,0BAA0B,EAC1B,gBAAgB,EAChB,qBAAqB,GACtB,MAAM,wBAAwB,CAAC;AAChC,OAAO,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAC;AAClD,OAAO,EACL,iBAAiB,EACjB,4BAA4B,EAC5B,kBAAkB,EAClB,oBAAoB,GACrB,MAAM,oBAAoB,CAAC;AAI5B,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,WAAW,EAAE,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,oEAAoE;IACpE,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;CAC1B;AAED;;;;;;;;;;GAUG;AACH,wBAAsB,YAAY,CAAC,KAAK,EAAE,WAAW,GAAG,OAAO,CAAC,eAAe,CAAC,CAgG/E;AA8OD;;;;;;;;GAQG;AACH,wBAAuB,mBAAmB,CAAC,KAAK,EAAE,WAAW,GAAG,aAAa,CAAC,MAAM,CAAC,CA6HpF;AAED,wBAAsB,aAAa,CAAC,CAAC,SAAS,CAAC,CAAC,UAAU,EACxD,KAAK,EAAE,WAAW,GAAG;IAAE,YAAY,EAAE,CAAC,CAAA;CAAE,GACvC,OAAO,CAAC,YAAY,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;AACrC,wBAAsB,aAAa,CAAC,KAAK,EAAE,WAAW,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;AAiG/E;;;;;;;;;GASG;AACH,wBAAsB,oBAAoB,CAAC,KAAK,EAAE;IAChD,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,UAAU,CAAC;IACjB,OAAO,EAAE,OAAO,CAAC;IACjB,OAAO,CAAC,EAAE,WAAW,EAAE,CAAC;CACzB,GAAG,OAAO,CAAC,MAAM,CAAC,CA8BlB"}
+{"version":3,"file":"answer.d.ts","sourceRoot":"","sources":["../src/answer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAC7B,OAAO,EACL,KAAK,WAAW,EAChB,KAAK,YAAY,EAGjB,KAAK,OAAO,EACb,MAAM,mBAAmB,CAAC;AAC3B,OAAO,KAAK,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAC;AAmCzE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAG9C,OAAO,EACL,KAAK,WAAW,EAChB,KAAK,YAAY,EACjB,KAAK,eAAe,EACpB,iBAAiB,EACjB,KAAK,OAAO,GACb,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EACL,gBAAgB,EAChB,qBAAqB,EACrB,sBAAsB,EACtB,0BAA0B,EAC1B,gBAAgB,EAChB,qBAAqB,GACtB,MAAM,wBAAwB,CAAC;AAChC,OAAO,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAC;AAClD,OAAO,EACL,iBAAiB,EACjB,4BAA4B,EAC5B,kBAAkB,EAClB,oBAAoB,GACrB,MAAM,oBAAoB,CAAC;AAa5B,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,WAAW,EAAE,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,oEAAoE;IACpE,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;CAC1B;AAED;;;;;;;;;;GAUG;AACH,wBAAsB,YAAY,CAAC,KAAK,EAAE,WAAW,GAAG,OAAO,CAAC,eAAe,CAAC,CAgG/E;AAgPD;;;;;;;;GAQG;AACH,wBAAuB,mBAAmB,CAAC,KAAK,EAAE,WAAW,GAAG,aAAa,CAAC,MAAM,CAAC,CA6HpF;AAED,wBAAsB,aAAa,CAAC,CAAC,SAAS,CAAC,CAAC,UAAU,EACxD,KAAK,EAAE,WAAW,GAAG;IAAE,YAAY,EAAE,CAAC,CAAA;CAAE,GACvC,OAAO,CAAC,YAAY,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;AACrC,wBAAsB,aAAa,CAAC,KAAK,EAAE,WAAW,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;AAiG/E;;;;;;;;;GASG;AACH,wBAAsB,oBAAoB,CAAC,KAAK,EAAE;IAChD,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,UAAU,CAAC;IACjB,OAAO,EAAE,OAAO,CAAC;IACjB,OAAO,CAAC,EAAE,WAAW,EAAE,CAAC;CACzB,GAAG,OAAO,CAAC,MAAM,CAAC,CA8BlB"}

package/dist/answer.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=answer.test.d.ts.map

package/dist/answer.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"answer.test.d.ts","sourceRoot":"","sources":["../src/answer.test.ts"],"names":[],"mappings":""}

package/dist/index.js

@@ -59803,6 +59803,17 @@ function classifyTopicAll(question) {
 var KNOWN_TOPICS = TOPIC_PATTERNS.map((p) => p.topic);
 
 // src/answer.ts
+function toolCallsToGroundingContext(records) {
+  if (!records || records.length === 0)
+    return "";
+  const lines = records.map((record2, index) => {
+    const result = typeof record2.result === "string" ? record2.result : JSON.stringify(record2.result);
+    return `[#tool-${index + 1}] ${record2.name}: ${result ?? ""}`;
+  });
+  return `TOOL RESULTS:
+${lines.join(`
+`)}`;
+}
 async function retrieveHits(input) {
   const topK = input.topK ?? 5;
   const candidateK = input.reranker ? topK * 3 : topK;
@@ -60001,10 +60012,14 @@ ${kbContextStr}` : vacBlock : kbContextStr;
   const groundingExempt = input.stage !== undefined && GROUNDING_EXEMPT_STAGES.has(input.stage);
   const runFactCheck = (input.reflect || runVacancyCheck) && text !== NO_CONTEXT_MARKER && text.trim().length > 0 && !(groundingExempt && !runVacancyCheck);
   if (runFactCheck) {
+    const toolContext = toolCallsToGroundingContext(multiCycleToolCalls);
+    const groundingContext = toolContext ? [context, toolContext].filter(Boolean).join(`
+
+`) : context;
     const verdict = await checkFacts({
       question: input.question,
       answer: text,
-      context,
+      context: groundingContext,
       chat: input.chat,
       ...runVacancyCheck ? { vacanciesBlock: vacBlock } : {}
     });

package/dist/ingest.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=ingest.test.d.ts.map

package/dist/ingest.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ingest.test.d.ts","sourceRoot":"","sources":["../src/ingest.test.ts"],"names":[],"mappings":""}

package/dist/system-prompt.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=system-prompt.test.d.ts.map

package/dist/system-prompt.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"system-prompt.test.d.ts","sourceRoot":"","sources":["../src/system-prompt.test.ts"],"names":[],"mappings":""}

package/dist/vision.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=vision.test.d.ts.map

package/dist/vision.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vision.test.d.ts","sourceRoot":"","sources":["../src/vision.test.ts"],"names":[],"mappings":""}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chatman-media/kb",
-  "version": "1.5.0",
+  "version": "1.6.0",
   "description": "Tenant-scoped Knowledge Base: hybrid retrieval (pgvector + BM25), ingest, answer pipeline, persona/skill composition. LLM I/O живёт в @chatman-media/llm-router.",
   "type": "module",
   "main": "./dist/index.js",

package/src/answer.test.ts

@@ -0,0 +1,380 @@
+// Unit tests for the RAG answer pipeline (answer.ts): retrieveHits,
+// answerWithRag (+ its answerFromHits branches), answerWithRagStream and
+// generateSoftFallback. The KB store, embedder and chat client are faked so
+// every branch (shortcuts, no-context, structured output, tool loop, fact
+// check drops, retrieval failure, streaming) runs without network or DB.
+
+import { describe, expect, it } from "bun:test";
+import type { ChatClient, ChatMessage, EmbeddingClient } from "@chatman-media/llm-router";
+import { z } from "zod";
+import {
+  answerWithRag,
+  answerWithRagStream,
+  generateSoftFallback,
+  NO_CONTEXT_MARKER,
+  retrieveHits,
+} from "./answer.ts";
+import type { AnswerInput } from "./answer-types.ts";
+import type { KbSearchHit } from "./types.ts";
+
+const hit = (id: number, over: Partial<KbSearchHit> = {}): KbSearchHit => ({
+  chunk_id: id,
+  distance: 0.1,
+  text: `chunk ${id}`,
+  document_id: 1,
+  source: "src",
+  title: `title ${id}`,
+  ...over,
+});
+
+const embedder: EmbeddingClient = {
+  embed: async (inputs: string[]) => inputs.map(() => [1, 0, 0]),
+  dim: 3,
+};
+
+function fakeKb(
+  over: Partial<Record<keyof FakeKbCalls, unknown>> = {},
+  hits: KbSearchHit[] = [hit(1)],
+) {
+  const calls: FakeKbCalls = { search: 0, hybrid: 0, priority: 0 };
+  const store = {
+    search: async (_e: number[], _k: number, topic?: string | null) => {
+      calls.search++;
+      calls.lastTopic = topic ?? null;
+      return (over.search as KbSearchHit[] | undefined) ?? hits;
+    },
+    hybridSearch: async () => {
+      calls.hybrid++;
+      return (over.hybrid as KbSearchHit[] | undefined) ?? hits;
+    },
+    prioritySearch: async () => {
+      calls.priority++;
+      return (over.priority as KbSearchHit[] | undefined) ?? hits;
+    },
+  } as unknown as AnswerInput["kb"];
+  return { store, calls };
+}
+interface FakeKbCalls {
+  search: number;
+  hybrid: number;
+  priority: number;
+  lastTopic?: string | null;
+}
+
+/** Chat client whose complete() returns a fixed string and records messages. */
+function fakeChat(
+  reply: string | ((m: ChatMessage[]) => string),
+  extra: Partial<ChatClient> = {},
+): ChatClient & { lastMessages?: ChatMessage[] } {
+  const c: ChatClient & { lastMessages?: ChatMessage[] } = {
+    complete: async (messages: ChatMessage[]) => {
+      c.lastMessages = messages;
+      return typeof reply === "function" ? reply(messages) : reply;
+    },
+    ...extra,
+  };
+  return c;
+}
+
+const baseInput = (over: Partial<AnswerInput> = {}): AnswerInput => {
+  const { store } = fakeKb();
+  return {
+    question: "Расскажи про вакансию в Китае и условия", // job intent → not a shortcut
+    kb: store,
+    embedder,
+    chat: fakeChat("ответ модели"),
+    ...over,
+  };
+};
+
+describe("retrieveHits", () => {
+  it("single-query vector search, без topic", async () => {
+    const { store, calls } = fakeKb();
+    const r = await retrieveHits(baseInput({ kb: store }));
+    expect(r.hits).toHaveLength(1);
+    expect(calls.search).toBe(1);
+    expect(r.searchQuery).toContain("вакансию");
+  });
+
+  it("hybridSearch path", async () => {
+    const { store, calls } = fakeKb();
+    await retrieveHits(baseInput({ kb: store, hybridSearch: true }));
+    expect(calls.hybrid).toBe(1);
+    expect(calls.search).toBe(0);
+  });
+
+  it("booksPriority path", async () => {
+    const { store, calls } = fakeKb();
+    const r = await retrieveHits(baseInput({ kb: store, booksPriority: true }));
+    expect(calls.priority).toBe(1);
+    expect(r.usedTopic).toBeNull();
+  });
+
+  it("topicRouting: пустой результат по topic → fallback на global (usedTopic=null)", async () => {
+    let first = true;
+    const store = {
+      search: async () => {
+        if (first) {
+          first = false;
+          return [];
+        }
+        return [hit(2)];
+      },
+      hybridSearch: async () => [],
+      prioritySearch: async () => [],
+    } as unknown as AnswerInput["kb"];
+    const r = await retrieveHits(
+      baseInput({ kb: store, topicRouting: true, question: "виза china" }),
+    );
+    // fell back to global → got the hit, usedTopic reset to null
+    expect(r.usedTopic).toBeNull();
+  });
+
+  it("maxDistance фильтрует далёкие хиты (non-hybrid)", async () => {
+    const { store } = fakeKb({}, [hit(1, { distance: 0.1 }), hit(2, { distance: 0.9 })]);
+    const r = await retrieveHits(baseInput({ kb: store, maxDistance: 0.5 }));
+    expect(r.hits.map((h) => h.chunk_id)).toEqual([1]);
+  });
+
+  it("multiQuery → expandQueries + RRF merge", async () => {
+    const { store, calls } = fakeKb({}, [hit(1), hit(2)]);
+    // expandQueries uses chat to generate variants; a chat returning lines works,
+    // but multiQuery merges per-query result lists regardless of expansion output.
+    const r = await retrieveHits(
+      baseInput({ kb: store, multiQuery: true, chat: fakeChat("вариант1\nвариант2") }),
+    );
+    expect(r.queries.length).toBeGreaterThanOrEqual(1);
+    expect(calls.search).toBeGreaterThanOrEqual(1);
+  });
+
+  it("embedder без вектора → throw", async () => {
+    const empty: EmbeddingClient = { embed: async () => [], dim: 3 };
+    await expect(retrieveHits(baseInput({ embedder: empty }))).rejects.toThrow(/no vector/);
+  });
+});
+
+describe("answerWithRag — persona shortcuts", () => {
+  it("smalltalk «кто ты?» → path=smalltalk, без LLM", async () => {
+    const chat = fakeChat(() => {
+      throw new Error("should not call LLM");
+    });
+    const r = await answerWithRag(baseInput({ question: "кто ты?", chat }));
+    expect(r.telemetry.path).toBe("smalltalk");
+    expect(r.hits).toHaveLength(0);
+  });
+
+  it("bot-presence «ты бот?» → path=smalltalk", async () => {
+    const r = await answerWithRag(baseInput({ question: "ты бот?" }));
+    expect(r.telemetry.path).toBe("smalltalk");
+  });
+
+  it("personal-fact «где ты живёшь?» с persona.facts → path=persona_fact", async () => {
+    const r = await answerWithRag(
+      baseInput({
+        question: "где ты живёшь?",
+        persona: { name: "Аня", role: "human", facts: { city: "Москва" } },
+      }),
+    );
+    expect(r.telemetry.path).toBe("persona_fact");
+    expect(r.text).toContain("Москва");
+  });
+});
+
+describe("answerWithRag — main paths", () => {
+  it("happy path: hits + LLM → path=ok, usedChunkIds", async () => {
+    const onTel: unknown[] = [];
+    const r = await answerWithRag(baseInput({ onTelemetry: (t) => onTel.push(t) }));
+    expect(r.telemetry.path).toBe("ok");
+    expect(r.text.toLowerCase()).toBe("ответ модели");
+    expect(r.usedChunkIds).toEqual([1]);
+    expect(onTel).toHaveLength(1);
+  });
+
+  it("нет hits, нет style/vac/tools → NO_CONTEXT_MARKER", async () => {
+    const { store } = fakeKb({ search: [] });
+    const r = await answerWithRag(baseInput({ kb: store }));
+    expect(r.text).toBe(NO_CONTEXT_MARKER);
+    expect(r.telemetry.path).toBe("no_context");
+  });
+
+  it("retrieval падает → отвечаем без базы (graceful)", async () => {
+    const store = {
+      search: async () => {
+        throw new Error("vector down");
+      },
+      hybridSearch: async () => [],
+      prioritySearch: async () => [],
+    } as unknown as AnswerInput["kb"];
+    // no style → with zero hits answerFromHits returns no_context (no throw)
+    const r = await answerWithRag(baseInput({ kb: store }));
+    expect(r.text).toBe(NO_CONTEXT_MARKER);
+  });
+
+  it("structured output через completeStructured", async () => {
+    const schema = z.object({ ok: z.boolean() });
+    const chat = fakeChat("unused", {
+      completeStructured: async () => '{"ok":true}',
+    });
+    const r = await answerWithRag({ ...baseInput({ chat }), outputSchema: schema });
+    expect(r.output).toEqual({ ok: true });
+    expect(r.telemetry.path).toBe("ok");
+  });
+
+  it("structured output fallback (нет completeStructured) → inject + complete temp0", async () => {
+    const schema = z.object({ n: z.number() });
+    const chat = fakeChat('{"n":7}');
+    const r = await answerWithRag({ ...baseInput({ chat }), outputSchema: schema });
+    expect(r.output).toEqual({ n: 7 });
+  });
+
+  it("fact-check (reflect): ungrounded → дроп в NO_CONTEXT_MARKER, path=ungrounded", async () => {
+    const chat = fakeChat((m) => {
+      // checkFacts uses the last system prompt asking for JSON verdict
+      const sys = m[0]?.content ?? "";
+      return sys.includes("grounded")
+        ? '{"grounded":false,"vacancyOk":true,"reason":"выдумал"}'
+        : "сырой ответ";
+    });
+    const r = await answerWithRag(baseInput({ chat, reflect: true, stage: "pitch" }));
+    expect(r.telemetry.path).toBe("ungrounded");
+    expect(r.text).toBe(NO_CONTEXT_MARKER);
+  });
+
+  it("vacancyGuard: mismatched vacancy → дроп", async () => {
+    const chat = fakeChat((m) => {
+      const sys = m[0]?.content ?? "";
+      return sys.includes("grounded")
+        ? '{"grounded":true,"vacancyOk":false,"reason":"цифры"}'
+        : "ответ с вакансией";
+    });
+    const r = await answerWithRag(
+      baseInput({ chat, vacanciesBlock: "Вакансия 2000$", stage: "pitch" }),
+    );
+    expect(r.telemetry.path).toBe("ungrounded");
+  });
+
+  it("grounding-exempt стадия (qualify) без vacancy → fact-check скипается", async () => {
+    let factCheckCalled = false;
+    const chat = fakeChat((m) => {
+      if ((m[0]?.content ?? "").includes("grounded")) {
+        factCheckCalled = true;
+        return '{"grounded":false,"vacancyOk":true}';
+      }
+      return "вопрос кандидату";
+    });
+    const r = await answerWithRag(baseInput({ chat, reflect: true, stage: "qualify" }));
+    expect(factCheckCalled).toBe(false);
+    expect(r.telemetry.path).toBe("ok");
+  });
+
+  it("tool-loop: модель отвечает без вызова tools → early-return ok", async () => {
+    const chat = fakeChat("unused", {
+      completeWithTools: async () => ({ content: "финальный ответ", toolCalls: [] }),
+    }) as ChatClient;
+    const tool = {
+      name: "quote",
+      description: "d",
+      parameters: z.object({}),
+      execute: async () => "x",
+    };
+    const r = await answerWithRag(
+      baseInput({ chat, tools: [tool] as unknown as AnswerInput["tools"] }),
+    );
+    expect(r.text.toLowerCase()).toBe("финальный ответ");
+    expect(r.telemetry.path).toBe("ok");
+  });
+
+  it("fact-check sees tool results as grounding context", async () => {
+    let calls = 0;
+    let checkerPrompt = "";
+    const chat = fakeChat("unused", {
+      completeWithTools: async () => {
+        calls++;
+        if (calls === 1) {
+          return {
+            content: null,
+            toolCalls: [{ id: "q1", name: "quote", args: { asset: "USDT", amount: 335 } }],
+          };
+        }
+        return { content: "Курс 31.5, получите 10553 THB.", toolCalls: [] };
+      },
+      complete: async (messages: ChatMessage[]) => {
+        if ((messages[0]?.content ?? "").includes("grounded")) {
+          checkerPrompt = messages[1]?.content ?? "";
+          return '{"grounded":true,"vacancyOk":true}';
+        }
+        return "Курс 31.5, получите 10553 THB.";
+      },
+    }) as ChatClient;
+    const tool = {
+      name: "quote",
+      description: "d",
+      parameters: z.object({ asset: z.string(), amount: z.number() }),
+      execute: async () => ({ rate: 31.5, amountToThb: 10553 }),
+    };
+    const r = await answerWithRag(
+      baseInput({ chat, reflect: true, tools: [tool] as unknown as AnswerInput["tools"] }),
+    );
+    expect(r.telemetry.path).toBe("ok");
+    expect(r.text).toContain("10553 THB");
+    expect(checkerPrompt).toContain("TOOL RESULTS");
+    expect(checkerPrompt).toContain("quote");
+    expect(checkerPrompt).toContain("10553");
+  });
+});
+
+describe("answerWithRagStream", () => {
+  async function collect(it: AsyncIterable<string>): Promise<string> {
+    let out = "";
+    for await (const t of it) out += t;
+    return out;
+  }
+
+  it("smalltalk shortcut → yield + telemetry", async () => {
+    const tel: { path?: string }[] = [];
+    const out = await collect(
+      answerWithRagStream(baseInput({ question: "кто ты?", onTelemetry: (t) => tel.push(t) })),
+    );
+    expect(out.length).toBeGreaterThan(0);
+    expect(tel[0]?.path).toBe("smalltalk");
+  });
+
+  it("no-context → yield NO_CONTEXT_MARKER", async () => {
+    const { store } = fakeKb({ search: [] });
+    const out = await collect(answerWithRagStream(baseInput({ kb: store })));
+    expect(out).toBe(NO_CONTEXT_MARKER);
+  });
+
+  it("stream() доступен → токены отдаются по одному", async () => {
+    const chat = fakeChat("unused", {
+      // eslint-disable-next-line require-yield
+      stream: async function* () {
+        yield "при";
+        yield "вет";
+      },
+    }) as ChatClient;
+    const out = await collect(answerWithRagStream(baseInput({ chat })));
+    expect(out).toBe("привет");
+  });
+
+  it("нет stream() → fallback на complete()", async () => {
+    const out = await collect(answerWithRagStream(baseInput({ chat: fakeChat("полный ответ") })));
+    // complete() fallback runs sanitizeLlmOutput (capitalises the first letter)
+    expect(out.toLowerCase()).toBe("полный ответ");
+  });
+});
+
+describe("generateSoftFallback", () => {
+  it("строит persona-промпт и санитизирует ответ", async () => {
+    const chat = fakeChat("Уточню и вернусь!");
+    const r = await generateSoftFallback({
+      question: "сколько платят?",
+      chat,
+      persona: { name: "Аня", role: "human", company: "Acme" },
+    });
+    expect(r).toBe("Уточню и вернусь!");
+    const sys = chat.lastMessages?.[0]?.content ?? "";
+    expect(sys).toContain("Аня");
+    expect(sys).toContain("Acme");
+  });
+});

package/src/answer.ts

@@ -33,7 +33,12 @@ import {
   legacyRagSamplingTemperature,
 } from "./system-prompt.ts";
 import { applyStyleRules } from "./text-style-rules.ts";
-import { buildToolTelemetry, DEFAULT_MAX_TOOL_CYCLES, runToolLoop } from "./tool-loop.ts";
+import {
+  buildToolTelemetry,
+  DEFAULT_MAX_TOOL_CYCLES,
+  runToolLoop,
+  type ToolCallRecord,
+} from "./tool-loop.ts";
 import type { AnyRagTool } from "./tools.ts";
 import { classifyTopic } from "./topic-classifier.ts";
 import type { KbSearchHit } from "./types.ts";
@@ -62,6 +67,15 @@ export {
   renderUserFactsBlock,
 } from "./system-prompt.ts";
 
+function toolCallsToGroundingContext(records: ToolCallRecord[] | undefined): string {
+  if (!records || records.length === 0) return "";
+  const lines = records.map((record, index) => {
+    const result = typeof record.result === "string" ? record.result : JSON.stringify(record.result);
+    return `[#tool-${index + 1}] ${record.name}: ${result ?? ""}`;
+  });
+  return `TOOL RESULTS:\n${lines.join("\n")}`;
+}
+
 // ── Shared retrieval ─────────────────────────────────────────────────────────
 
 export interface RetrievalResult {
@@ -368,10 +382,12 @@ async function answerFromHits(opts: {
     !(groundingExempt && !runVacancyCheck);
 
   if (runFactCheck) {
+    const toolContext = toolCallsToGroundingContext(multiCycleToolCalls);
+    const groundingContext = toolContext ? [context, toolContext].filter(Boolean).join("\n\n") : context;
     const verdict = await checkFacts({
       question: input.question,
       answer: text,
-      context,
+      context: groundingContext,
       chat: input.chat,
       ...(runVacancyCheck ? { vacanciesBlock: vacBlock } : {}),
     });

package/src/ingest.test.ts

@@ -0,0 +1,178 @@
+// Unit tests for the ingest pipeline (ingestFile / ingestText / ingestDirectory)
+// + the pure helpers (deriveTopicFromPath, stripNonContent). The KB store and
+// embedder are faked; ingestFile/ingestDirectory use real temp files on disk.
+
+import { afterEach, describe, expect, it } from "bun:test";
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import type { EmbeddingClient } from "@chatman-media/llm-router";
+import {
+  deriveTopicFromPath,
+  type IngestDeps,
+  ingestDirectory,
+  ingestFile,
+  ingestText,
+  stripNonContent,
+} from "./ingest.ts";
+import type { IKbStore } from "./types.ts";
+
+interface FakeStoreState {
+  docs: Map<string, { id: number; content_hash: string; chunkCount: number }>;
+  inserted: number;
+  deleted: number[];
+  nextId: number;
+}
+
+function fakeStore(state: FakeStoreState): IKbStore {
+  return {
+    search: async () => [],
+    hybridSearch: async () => [],
+    prioritySearch: async () => [],
+    getDocumentBySource: async (source: string) => {
+      const d = state.docs.get(source);
+      return d ? { id: d.id, content_hash: d.content_hash } : null;
+    },
+    countChunksForDocument: async (id: number) => {
+      for (const d of state.docs.values()) if (d.id === id) return d.chunkCount;
+      return 0;
+    },
+    deleteDocument: async (id: number) => {
+      state.deleted.push(id);
+      return true;
+    },
+    upsertDocument: async (input: { source: string; contentHash: string }) => {
+      const id = state.nextId++;
+      state.docs.set(input.source, { id, content_hash: input.contentHash, chunkCount: 0 });
+      return { id };
+    },
+    insertChunkWithEmbedding: async () => {
+      state.inserted++;
+    },
+  } as unknown as IKbStore;
+}
+
+function newState(): FakeStoreState {
+  return { docs: new Map(), inserted: 0, deleted: [], nextId: 1 };
+}
+
+const embedder: EmbeddingClient = {
+  embed: async (inputs: string[]) => inputs.map(() => [0.1, 0.2, 0.3]),
+  dim: 3,
+};
+
+const tmpDirs: string[] = [];
+function tmp(): string {
+  const d = mkdtempSync(join(tmpdir(), "kb-ingest-"));
+  tmpDirs.push(d);
+  return d;
+}
+afterEach(() => {
+  while (tmpDirs.length) rmSync(tmpDirs.pop() as string, { recursive: true, force: true });
+});
+
+describe("stripNonContent", () => {
+  it("снимает YAML-frontmatter", () => {
+    expect(stripNonContent("---\ntitle: x\n---\nBody here")).toBe("Body here\n");
+  });
+  it("снимает HTML-комментарии (в т.ч. вложенный остаток)", () => {
+    expect(stripNonContent("a<!-- c -->b")).toBe("ab\n");
+  });
+  it("схлопывает 3+ переводов строк", () => {
+    expect(stripNonContent("a\n\n\n\nb")).toBe("a\n\nb\n");
+  });
+});
+
+describe("deriveTopicFromPath", () => {
+  it("файл прямо в root → null", () => {
+    expect(deriveTopicFromPath("/r/a.md", "/r")).toBeNull();
+  });
+  it("первая поддиректория → topic", () => {
+    expect(deriveTopicFromPath("/r/china/jobs/a.md", "/r")).toBe("china");
+  });
+});
+
+describe("ingestText", () => {
+  it("создаёт документ и чанки, source=inline:<hash12>", async () => {
+    const state = newState();
+    const deps: IngestDeps = { kb: fakeStore(state), embedder };
+    const r = await ingestText({ title: "Doc", body: "some content body text" }, deps);
+    expect(r.created).toBe(true);
+    expect(r.source).toStartWith("inline:");
+    expect(r.chunks).toBeGreaterThan(0);
+    expect(state.inserted).toBe(r.chunks);
+  });
+
+  it("пустой title → 'untitled'; пустое тело → 0 чанков", async () => {
+    const state = newState();
+    const r = await ingestText({ title: "  ", body: "" }, { kb: fakeStore(state), embedder });
+    expect(r.chunks).toBe(0);
+    expect(state.inserted).toBe(0);
+  });
+
+  it("повторная загрузка идентичного контента → dedup (created:false)", async () => {
+    const state = newState();
+    const deps: IngestDeps = { kb: fakeStore(state), embedder };
+    const first = await ingestText({ title: "D", body: "stable text payload" }, deps);
+    // mark existing doc as having chunks so the dedup short-circuit fires
+    for (const d of state.docs.values()) d.chunkCount = first.chunks;
+    const second = await ingestText({ title: "D", body: "stable text payload" }, deps);
+    expect(second.created).toBe(false);
+    expect(second.documentId).toBe(first.documentId);
+  });
+
+  it("существующий док с другим hash → удаляется и пересоздаётся", async () => {
+    const state = newState();
+    const deps: IngestDeps = { kb: fakeStore(state), embedder, topic: "t" };
+    const first = await ingestText({ title: "D", body: "version one" }, deps);
+    for (const d of state.docs.values()) d.chunkCount = first.chunks;
+    // same source (hash of inline depends on body) — change body keeps a NEW source,
+    // so to force the delete path we reuse the same body but reset stored hash.
+    for (const d of state.docs.values()) d.content_hash = "STALE";
+    const second = await ingestText({ title: "D", body: "version one" }, deps);
+    expect(second.created).toBe(true);
+    expect(state.deleted.length).toBe(1);
+  });
+});
+
+describe("ingestFile", () => {
+  it("читает .md, стрипает frontmatter, индексирует чанки", async () => {
+    const dir = tmp();
+    const file = join(dir, "doc.md");
+    writeFileSync(file, "---\nx: 1\n---\nHello world content here.", "utf8");
+    const state = newState();
+    const r = await ingestFile(file, { kb: fakeStore(state), embedder });
+    expect(r.created).toBe(true);
+    expect(r.source).toBe(`file://${file}`);
+    expect(r.chunks).toBeGreaterThan(0);
+  });
+
+  it("source/title override", async () => {
+    const dir = tmp();
+    const file = join(dir, "tmpname.txt");
+    writeFileSync(file, "body text", "utf8");
+    const state = newState();
+    const r = await ingestFile(file, {
+      kb: fakeStore(state),
+      embedder,
+      source: "upload:abc",
+      title: "Nice Title",
+    });
+    expect(r.source).toBe("upload:abc");
+  });
+});
+
+describe("ingestDirectory", () => {
+  it("обходит дерево, пропускает неподдерживаемые расширения, выводит topic из подпапки", async () => {
+    const root = tmp();
+    mkdirSync(join(root, "china"));
+    writeFileSync(join(root, "china", "a.md"), "alpha content", "utf8");
+    writeFileSync(join(root, "b.txt"), "bravo content", "utf8");
+    writeFileSync(join(root, "skip.json"), "{}", "utf8");
+    const state = newState();
+    const summary = await ingestDirectory(root, { kb: fakeStore(state), embedder });
+    expect(summary.documents).toBe(2);
+    expect(summary.skipped).toBe(1);
+    expect(summary.chunks).toBeGreaterThan(0);
+  });
+});

package/src/prompt.test.ts

@@ -19,6 +19,154 @@ const baseStyle: Style = {
   model: { id: "x", temperature: 0.5, maxTokens: 100 },
 };
 
+describe("composeSystemPrompt — persona / voice / framework blocks", () => {
+  it("human persona: менеджер агентства + честное раскрытие бота (botDisclosure=true)", () => {
+    const p = composeSystemPrompt(
+      { ...baseStyle, persona: { name: "Аня", role: "human", company: "Acme" } },
+      "qualify",
+    );
+    expect(p).toContain("менеджер агентства Acme");
+    expect(p).toContain("ЧЕСТНО ответь, что ты ИИ-ассистент");
+    expect(p).toContain("ФРЕЙМВОРК");
+  });
+
+  it("human persona, botDisclosure=false → уклончивый ответ про бота", () => {
+    const s: Style = {
+      ...baseStyle,
+      guardrails: { ...baseStyle.guardrails, botDisclosureOnDirectQuestion: false },
+    };
+    const p = composeSystemPrompt(s, "qualify");
+    expect(p).toContain("отвечай уклончиво");
+  });
+
+  it("assistant persona: ИИ-ассистент", () => {
+    const p = composeSystemPrompt(
+      { ...baseStyle, persona: { name: "Бот", role: "assistant", company: "Acme" } },
+      "qualify",
+    );
+    expect(p).toContain("ИИ-ассистент агентства Acme");
+  });
+
+  it("persona.facts → блок личных фактов", () => {
+    const p = composeSystemPrompt(
+      { ...baseStyle, persona: { name: "Аня", role: "human", facts: { age: "25", empty: " " } } },
+      "qualify",
+    );
+    expect(p).toContain("ЛИЧНЫЕ ФАКТЫ");
+    expect(p).toContain("age: 25");
+    expect(p).not.toContain("empty");
+  });
+
+  it("voice.forbid → блок ЗАПРЕЩЕНО; язык en", () => {
+    const p = composeSystemPrompt(
+      { ...baseStyle, voice: { tone: "bold", language: "en", forbid: ["мат", "сленг"] } },
+      "qualify",
+    );
+    expect(p).toContain("Язык: английский");
+    expect(p).toContain("ЗАПРЕЩЕНО: мат; сленг");
+  });
+});
+
+describe("composeSystemPrompt — hooks / director hooks / skills", () => {
+  it("hooks → блок ХУКИ с лейблами", () => {
+    const p = composeSystemPrompt(
+      { ...baseStyle, hooks: [{ kind: "scarcity", text: "осталось 3 места" }] },
+      "qualify",
+    );
+    expect(p).toContain("ДЕФИЦИТ: осталось 3 места");
+  });
+
+  it("directorHooks → блок ХУКИ УБЕЖДЕНИЯ + triggerHint", () => {
+    const p = composeSystemPrompt(baseStyle, "qualify", null, {
+      directorHooks: [{ name: "FOMO", body: "дави на срочность", triggerHint: "колеблется" }],
+    });
+    expect(p).toContain("ХУКИ УБЕЖДЕНИЯ");
+    expect(p).toContain("FOMO");
+    expect(p).toContain("Когда: колеблется");
+  });
+
+  it("skills фильтруются по стадии", () => {
+    const p = composeSystemPrompt(baseStyle, "qualify", null, {
+      skills: [
+        { slug: "mirror", displayName: "Зеркало", promptFragment: "отражай", applicableStages: ["qualify"] },
+        { slug: "close", displayName: "Закрытие", promptFragment: "закрывай", applicableStages: ["close"] },
+        { slug: "always", displayName: "Всегда", promptFragment: "везде", applicableStages: [] },
+      ],
+    });
+    expect(p).toContain("ПРИЁМЫ");
+    expect(p).toContain("Зеркало");
+    expect(p).toContain("Всегда");
+    expect(p).not.toContain("Закрытие");
+  });
+});
+
+describe("composeSystemPrompt — support mode / grounding / few-shot", () => {
+  it("supportPhase=docs → блок поддержки, sales-блоки выкинуты", () => {
+    const s: Style = { ...baseStyle, hooks: [{ kind: "scarcity", text: "x" }] };
+    const p = composeSystemPrompt(s, "qualify", null, { supportPhase: "docs" });
+    expect(p).toContain("РЕЖИМ ПОДДЕРЖКИ");
+    expect(p).toContain("около 10 дней");
+    expect(p).not.toContain("ФРЕЙМВОРК");
+    expect(p).not.toContain("ДЕФИЦИТ");
+  });
+
+  it("supportPhase=submitted → текст про консульство", () => {
+    const p = composeSystemPrompt(baseStyle, "qualify", null, { supportPhase: "submitted" });
+    expect(p).toContain("подана в консульство");
+  });
+
+  it("groundingRequired + нет KB контекста → напоминание о grounding (human)", () => {
+    const s: Style = {
+      ...baseStyle,
+      persona: { name: "Аня", role: "human" },
+      stages: { qualify: { goal: "G", groundingRequired: true } },
+    };
+    const p = composeSystemPrompt(s, "qualify");
+    expect(p).toContain("GROUNDING");
+    expect(p).toContain("Никогда не выдумывай");
+  });
+
+  it("groundingRequired + есть KB контекст → KB CONTEXT присутствует", () => {
+    const s: Style = {
+      ...baseStyle,
+      stages: { qualify: { goal: "G", groundingRequired: true } },
+    };
+    const p = composeSystemPrompt(s, "qualify", "факт: зарплата 1500");
+    expect(p).toContain("KB CONTEXT");
+  });
+
+  it("few-shot включается по умолчанию и выключается флагом", () => {
+    const s: Style = {
+      ...baseStyle,
+      fewShot: [{ user: "сколько?", assistant: "уточню", stage: "qualify" }],
+    };
+    expect(composeSystemPrompt(s, "qualify")).toContain("ПРИМЕРЫ ДИАЛОГА");
+    expect(composeSystemPrompt(s, "qualify", null, { includeFewShot: false })).not.toContain(
+      "ПРИМЕРЫ ДИАЛОГА",
+    );
+  });
+
+  it("guardrails: noMinors + forbiddenTopics → жёсткие правила", () => {
+    const s: Style = {
+      ...baseStyle,
+      guardrails: {
+        noMinors: true,
+        botDisclosureOnDirectQuestion: true,
+        forbiddenTopics: ["политика"],
+      },
+    };
+    const p = composeSystemPrompt(s, "qualify");
+    expect(p).toContain("ЖЁСТКИЕ ПРАВИЛА");
+    expect(p).toContain("<18 лет");
+    expect(p).toContain("Запрещённые темы: политика");
+  });
+
+  it("стадия без конфига и без override → generic-блок", () => {
+    const p = composeSystemPrompt(baseStyle, "pitch");
+    expect(p).toContain("Специфических правил для этапа нет");
+  });
+});
+
 describe("composeSystemPrompt — stageOverride (Phase 2 C-2)", () => {
   it("без override → goal берётся из Style", () => {
     const p = composeSystemPrompt(baseStyle, "qualify");

package/src/system-prompt.test.ts

@@ -0,0 +1,81 @@
+// Unit tests for the legacy (non-style) system-prompt builder and its block
+// renderers. Pure functions — no fakes needed.
+
+import { describe, expect, it } from "bun:test";
+import {
+  buildSystemPrompt,
+  DEFAULT_PERSONA,
+  legacyRagSamplingTemperature,
+  renderSummaryBlock,
+  renderUserFactsBlock,
+} from "./system-prompt.ts";
+
+describe("legacyRagSamplingTemperature", () => {
+  it("human → 0.55, assistant → 0.38", () => {
+    expect(legacyRagSamplingTemperature({ name: "x", role: "human" })).toBe(0.55);
+    expect(legacyRagSamplingTemperature({ name: "x", role: "assistant" })).toBe(0.38);
+  });
+  it("override имеет приоритет", () => {
+    expect(legacyRagSamplingTemperature(DEFAULT_PERSONA, 0.9)).toBe(0.9);
+  });
+});
+
+describe("renderSummaryBlock", () => {
+  it("пусто/whitespace → ''", () => {
+    expect(renderSummaryBlock()).toBe("");
+    expect(renderSummaryBlock("   ")).toBe("");
+  });
+  it("с текстом → блок «ИЗ РАННЕЙ ПЕРЕПИСКИ»", () => {
+    expect(renderSummaryBlock("обсудили визу")).toContain("ИЗ РАННЕЙ ПЕРЕПИСКИ");
+  });
+});
+
+describe("renderUserFactsBlock", () => {
+  it("undefined / только пустые значения → ''", () => {
+    expect(renderUserFactsBlock()).toBe("");
+    expect(renderUserFactsBlock({ city: "  " })).toBe("");
+  });
+  it("факты → bullet-список", () => {
+    const b = renderUserFactsBlock({ city: "Москва", age: "25" });
+    expect(b).toContain("- city: Москва");
+    expect(b).toContain("- age: 25");
+  });
+});
+
+describe("buildSystemPrompt", () => {
+  it("human persona: НИКОГДА не говори что ты ИИ + компания", () => {
+    const p = buildSystemPrompt({ name: "Аня", role: "human", company: "Acme" }, "CTX");
+    expect(p).toContain("Аня");
+    expect(p).toContain("Acme");
+    expect(p).toContain("НИКОГДА");
+    expect(p).toContain("ЖИВАЯ РЕЧЬ");
+    expect(p).toContain("CONTEXT:\nCTX");
+  });
+
+  it("assistant persona: ИИ-ассистент, без блока живой речи", () => {
+    const p = buildSystemPrompt({ name: "Бот", role: "assistant" }, "CTX");
+    expect(p).toContain("ИИ-ассистент");
+    expect(p).not.toContain("ЖИВАЯ РЕЧЬ");
+  });
+
+  it("persona.facts → блок ЛИЧНЫЕ ФАКТЫ (пустые отброшены)", () => {
+    const p = buildSystemPrompt(
+      { name: "Аня", role: "human", facts: { city: "Сочи", empty: "  " } },
+      "CTX",
+    );
+    expect(p).toContain("ЛИЧНЫЕ ФАКТЫ");
+    expect(p).toContain("city: Сочи");
+    expect(p).not.toContain("empty");
+  });
+
+  it("userFacts + summary секции добавляются", () => {
+    const p = buildSystemPrompt(
+      { name: "x", role: "assistant" },
+      "CTX",
+      { age: "30" },
+      "ранее обсудили",
+    );
+    expect(p).toContain("ЗНАЕМ О КАНДИДАТЕ");
+    expect(p).toContain("ИЗ РАННЕЙ ПЕРЕПИСКИ");
+  });
+});

package/src/vision.test.ts

@@ -0,0 +1,199 @@
+// Unit tests for the vision helpers: photo classification + passport identity
+// extraction. Both hit an OpenAI-compatible /chat/completions endpoint, so the
+// transport is exercised with a mock `fetch` (request shape, response parsing,
+// error branches). Pure parsers (`parsePhotoClass`, `parsePassportJson`) are
+// tested directly.
+
+import { describe, expect, it } from "bun:test";
+import type { FetchLike } from "@chatman-media/llm-router";
+import {
+  type ClassifyPhotoOptions,
+  classifyPhoto,
+  extractPassportIdentity,
+  parsePassportJson,
+  parsePhotoClass,
+} from "./vision.ts";
+
+const bytes = new TextEncoder().encode("fake-image").buffer as ArrayBuffer;
+
+interface MockCall {
+  url: string;
+  init: RequestInit;
+}
+
+/** Mock fetch that records the call and returns a JSON response. */
+function mockFetch(opts: {
+  status?: number;
+  body?: unknown;
+  nonJson?: boolean;
+  calls?: MockCall[];
+}): FetchLike {
+  const status = opts.status ?? 200;
+  return (async (url: string, init: RequestInit) => {
+    opts.calls?.push({ url, init });
+    return {
+      ok: status >= 200 && status < 300,
+      status,
+      json: async () => {
+        if (opts.nonJson) throw new Error("invalid json");
+        return opts.body ?? {};
+      },
+    } as Response;
+  }) as unknown as FetchLike;
+}
+
+function reply(content: string | undefined, finish = "stop") {
+  return { choices: [{ message: { content }, finish_reason: finish }] };
+}
+
+const base: Omit<ClassifyPhotoOptions, "fetch"> = {
+  bytes,
+  model: "vision-model",
+  apiKey: "sk-test",
+};
+
+describe("parsePhotoClass", () => {
+  it("распознаёт каждую категорию из свободного текста", () => {
+    expect(parsePhotoClass("passport")).toBe("passport");
+    expect(parsePhotoClass("это full_body фото")).toBe("full_body");
+    expect(parsePhotoClass("PORTRAIT.")).toBe("portrait");
+    expect(parsePhotoClass("other")).toBe("other");
+  });
+  it("неизвестный ответ → other", () => {
+    expect(parsePhotoClass("не знаю")).toBe("other");
+    expect(parsePhotoClass("")).toBe("other");
+  });
+});
+
+describe("classifyPhoto", () => {
+  it("требует apiKey", async () => {
+    await expect(classifyPhoto({ ...base, apiKey: "  ", fetch: mockFetch({}) })).rejects.toThrow(
+      /apiKey required/,
+    );
+  });
+
+  it("openrouter (default): шлёт reasoning:{enabled:false}, data-url, парсит ответ", async () => {
+    const calls: MockCall[] = [];
+    const cls = await classifyPhoto({
+      ...base,
+      fetch: mockFetch({ body: reply("full_body"), calls }),
+    });
+    expect(cls).toBe("full_body");
+    expect(calls).toHaveLength(1);
+    expect(calls[0]?.url).toBe("https://openrouter.ai/api/v1/chat/completions");
+    const body = JSON.parse(calls[0]?.init.body as string);
+    expect(body.reasoning).toEqual({ enabled: false });
+    expect(body.model).toBe("vision-model");
+    const imgPart = body.messages[1].content.find((p: { type: string }) => p.type === "image_url");
+    expect(imgPart.image_url.url).toStartWith("data:image/jpeg;base64,");
+    expect((calls[0]?.init.headers as Record<string, string>).authorization).toBe("Bearer sk-test");
+  });
+
+  it("openai provider: НЕ шлёт reasoning", async () => {
+    const calls: MockCall[] = [];
+    await classifyPhoto({
+      ...base,
+      provider: "openai",
+      fetch: mockFetch({ body: reply("portrait"), calls }),
+    });
+    const body = JSON.parse(calls[0]?.init.body as string);
+    expect(body.reasoning).toBeUndefined();
+  });
+
+  it("custom baseUrl c хвостовыми слэшами нормализуется + mimeType", async () => {
+    const calls: MockCall[] = [];
+    await classifyPhoto({
+      ...base,
+      baseUrl: "https://api.example.com/v9///",
+      mimeType: "image/png",
+      fetch: mockFetch({ body: reply("other"), calls }),
+    });
+    expect(calls[0]?.url).toBe("https://api.example.com/v9/chat/completions");
+    const body = JSON.parse(calls[0]?.init.body as string);
+    const imgPart = body.messages[1].content.find((p: { type: string }) => p.type === "image_url");
+    expect(imgPart.image_url.url).toStartWith("data:image/png;base64,");
+  });
+
+  it("HTTP-ошибка → throw с кодом", async () => {
+    await expect(
+      classifyPhoto({
+        ...base,
+        fetch: mockFetch({ status: 500, body: { error: { message: "boom" } } }),
+      }),
+    ).rejects.toThrow(/vision API error \(HTTP 500\): boom/);
+  });
+
+  it("payload.error при ok → throw", async () => {
+    await expect(
+      classifyPhoto({ ...base, fetch: mockFetch({ body: { error: { message: "rate" } } }) }),
+    ).rejects.toThrow(/rate/);
+  });
+
+  it("не-JSON ответ → throw", async () => {
+    await expect(
+      classifyPhoto({ ...base, fetch: mockFetch({ status: 502, nonJson: true }) }),
+    ).rejects.toThrow(/non-JSON response \(HTTP 502\)/);
+  });
+
+  it("пустой content → throw с finish_reason", async () => {
+    await expect(
+      classifyPhoto({ ...base, fetch: mockFetch({ body: reply(undefined, "length") }) }),
+    ).rejects.toThrow(/empty content \(finish_reason=length\)/);
+  });
+});
+
+describe("parsePassportJson", () => {
+  it("чистый JSON → trim + забор только известных полей", () => {
+    expect(parsePassportJson('{"family_name":" IVANOV ","given_name":"ANNA","extra":"x"}')).toEqual(
+      { family_name: "IVANOV", given_name: "ANNA" },
+    );
+  });
+  it("снимает think-теги и code-fence", () => {
+    expect(
+      parsePassportJson('<think>hmm</think>```json\n{"passport_number":"12 34"}\n```'),
+    ).toEqual({ passport_number: "12 34" });
+  });
+  it("нет фигурных скобок → {}", () => {
+    expect(parsePassportJson("ничего")).toEqual({});
+  });
+  it("битый JSON → {}", () => {
+    expect(parsePassportJson("{ broken")).toEqual({});
+  });
+  it("массив / не-объект → {}", () => {
+    expect(parsePassportJson("[1,2,3]")).toEqual({});
+  });
+  it("пустые / слишком длинные значения отбрасываются", () => {
+    const long = "x".repeat(101);
+    expect(parsePassportJson(`{"family_name":"   ","given_name":"${long}"}`)).toEqual({});
+  });
+});
+
+describe("extractPassportIdentity", () => {
+  it("требует apiKey", async () => {
+    await expect(
+      extractPassportIdentity({ ...base, apiKey: "", fetch: mockFetch({}) }),
+    ).rejects.toThrow(/apiKey required/);
+  });
+  it("парсит поля из ответа модели", async () => {
+    const r = await extractPassportIdentity({
+      ...base,
+      fetch: mockFetch({ body: reply('{"family_name":"PETROV","passport_expiry":"01.02.2030"}') }),
+    });
+    expect(r).toEqual({ family_name: "PETROV", passport_expiry: "01.02.2030" });
+  });
+  it("HTTP-ошибка → throw", async () => {
+    await expect(
+      extractPassportIdentity({ ...base, fetch: mockFetch({ status: 403, body: {} }) }),
+    ).rejects.toThrow(/OpenRouter error \(HTTP 403\)/);
+  });
+  it("не-JSON → throw", async () => {
+    await expect(
+      extractPassportIdentity({ ...base, fetch: mockFetch({ status: 500, nonJson: true }) }),
+    ).rejects.toThrow(/non-JSON response/);
+  });
+  it("пустой content → throw", async () => {
+    await expect(
+      extractPassportIdentity({ ...base, fetch: mockFetch({ body: reply(undefined) }) }),
+    ).rejects.toThrow(/empty content/);
+  });
+});