feat(assistant): самопровизиониране на schema-v2 корпуса + GET /assistant/health като доказателство за CD

.github/workflows/deploy.yml

@@ -489,3 +489,47 @@ jobs:
             [ -n "$value" ] || { echo "$name is empty; leaving the Worker secret unchanged."; continue; }
             printf '%s' "$value" | pnpm --filter @sigma/etl exec wrangler secret put "$name" --config wrangler.deploy.toml
           done
+
+      # #346: prove the assistant's schema corpus is indexed in the environment just deployed. LAST in the
+      # job on purpose: a red check must not leave the explorer and the ETL Workflow at different versions
+      # or skip the LOG_IP_KEY initialisation above — everything else has already shipped by now. The Worker
+      # provisions the corpus itself on first use (ensureSchemaCorpus, #328); GET /assistant/health is both
+      # the trigger and the proof — 200 only when every vector THIS build expects is readable in `schema-v2`
+      # with this build's text. Vectorize applies writes asynchronously, so the first call after a fresh
+      # deploy legitimately answers 503 with `upserted` > 0; retry for ~2 minutes before failing the deploy.
+      # Both environments sit behind Cloudflare Access, so the probe needs an Access SERVICE TOKEN
+      # (Environment secrets CF_ACCESS_CLIENT_ID / CF_ACCESS_CLIENT_SECRET) and the environment's public base
+      # URL (Environment variable SIGMA_WEB_URL). Until an environment defines SIGMA_WEB_URL the step is
+      # skipped with a notice — the deploy must never depend on configuration the environment was not given
+      # (docs/deploy.md §5). Only counters and an HTTP status are printed; the health body carries no text.
+      - name: Verify assistant schema corpus (#346)
+        if: steps.guard.outputs.ok == 'true'
+        env:
+          SIGMA_WEB_URL: ${{ vars.SIGMA_WEB_URL }}
+          CF_ACCESS_CLIENT_ID: ${{ secrets.CF_ACCESS_CLIENT_ID }}
+          CF_ACCESS_CLIENT_SECRET: ${{ secrets.CF_ACCESS_CLIENT_SECRET }}
+        run: |
+          if [ -z "$SIGMA_WEB_URL" ]; then
+            echo "::notice::SIGMA_WEB_URL is not set for this environment; skipping the assistant corpus check (#346)."
+            exit 0
+          fi
+          url="${SIGMA_WEB_URL%/}/assistant/health"
+          auth=()
+          if [ -n "$CF_ACCESS_CLIENT_ID" ] && [ -n "$CF_ACCESS_CLIENT_SECRET" ]; then
+            auth=(-H "CF-Access-Client-Id: $CF_ACCESS_CLIENT_ID" -H "CF-Access-Client-Secret: $CF_ACCESS_CLIENT_SECRET")
+          fi
+          if [ -n "$CF_ACCESS_CLIENT_ID$CF_ACCESS_CLIENT_SECRET" ] && [ "${#auth[@]}" = 0 ]; then
+            echo "::warning::Only one of CF_ACCESS_CLIENT_ID / CF_ACCESS_CLIENT_SECRET is set; probing WITHOUT an Access service token."
+          fi
+          for attempt in 1 2 3 4 5 6 7 8; do
+            : > /tmp/health.json
+            # curl's -w prints 000 itself on a transport failure; `|| true` only keeps `set -e` from
+            # aborting the loop. The body is counters-only JSON on success; anything else (an Access
+            # login page, a 5xx) is cut to one short line so the log never carries a page.
+            code="$(curl -sS "${auth[@]}" -o /tmp/health.json -w '%{http_code}' "$url" || true)"
+            echo "attempt $attempt: HTTP ${code:-000} $(head -c 300 /tmp/health.json | tr '\n' ' ')"
+            [ "$code" = "200" ] && exit 0
+            [ "$attempt" = 8 ] || sleep 15
+          done
+          echo "::error::assistant schema corpus is not fully indexed at $url after ~2 minutes (#346) — see the attempts above."
+          exit 1

apps/web/app/lib/assistant/agent.stream-error.test.ts

@@ -0,0 +1,93 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import { APICallError } from 'ai';
+import { MockLanguageModelV3 } from 'ai/test';
+import { runAssistant } from './agent';
+import type { ToolContext } from './tools';
+
+// The ONLY test that drives runAssistant through the real streamText loop. It exists for one
+// invariant the unit tests cannot see: the AI SDK's own DEFAULT `onError` is `console.error(error)`
+// — the RAW APICallError, whose own properties carry `requestBodyValues` (system prompt + the user's
+// messages) and `responseBody`. If agent.ts stops overriding it on streamText (not only on the UI
+// stream), the prompt lands in the tail log on every provider failure, and nothing else notices.
+const h = vi.hoisted(() => ({ model: undefined as unknown }));
+vi.mock('@ai-sdk/openai', () => ({
+  createOpenAI: () => ({ chat: () => h.model }),
+}));
+
+const QUESTION = 'колко плати община Пловдив на фирма Х през 2024';
+
+function failingModel(statusCode: number, isRetryable: boolean) {
+  return new MockLanguageModelV3({
+    doStream: async () => {
+      throw new APICallError({
+        // A provider body that quotes the prompt back — the echo sits in `.message`.
+        message: `upstream rejected: ${QUESTION}`,
+        url: 'https://api.bggpt.ai/v1/chat/completions',
+        requestBodyValues: { messages: [{ role: 'user', content: QUESTION }] },
+        statusCode,
+        responseBody: `{"error":{"message":"${QUESTION}"}}`,
+        isRetryable,
+      });
+    },
+  });
+}
+
+function ctx(): ToolContext {
+  return {
+    db: {} as never,
+    results: [],
+    rowsRead: 0,
+    rowsReadBudget: 1000,
+    userQuestion: QUESTION,
+  };
+}
+
+async function runToEnd(): Promise<string> {
+  const res = await runAssistant({
+    env: { BGGPT_API_KEY: 'k', MAX_STEPS: '1' },
+    ctx: ctx(),
+    messages: [{ id: 'u1', role: 'user', parts: [{ type: 'text', text: QUESTION }] }],
+  });
+  return res.text(); // draining the body drives the stream (and its error hooks) to completion
+}
+
+describe('runAssistant stream error logging', () => {
+  afterEach(() => vi.restoreAllMocks());
+
+  it('logs ONE redacted, tagged line and NEVER the raw error object (non-retryable 401)', async () => {
+    h.model = failingModel(401, false);
+    const error = vi.spyOn(console, 'error').mockImplementation(() => {});
+    const body = await runToEnd();
+
+    // What the client sees: our line, not the provider's.
+    expect(body).toContain('Асистентът временно не е достъпен');
+    expect(body).not.toContain('Пловдив');
+
+    // What the tail log sees: exactly one line, a string, redacted, with identifier-only context.
+    expect(error).toHaveBeenCalledTimes(1);
+    const [first] = error.mock.calls[0] ?? [];
+    expect(typeof first).toBe('string'); // the SDK default would pass the Error OBJECT here
+    expect(first).toMatch(/^\[assistant\] stream error: /);
+    expect(first).toContain('«редактирано»');
+    expect(first).toContain('status=401');
+    expect(first).toContain('retryable=false');
+    for (const call of error.mock.calls) {
+      for (const arg of call) {
+        expect(typeof arg).toBe('string');
+        expect(String(arg)).not.toContain('Пловдив');
+        expect(String(arg)).not.toContain('requestBodyValues');
+      }
+    }
+  });
+
+  it('keeps the status visible through the RetryError wrapper (retryable 429, maxRetries 1)', async () => {
+    h.model = failingModel(429, true);
+    const error = vi.spyOn(console, 'error').mockImplementation(() => {});
+    await runToEnd();
+    expect(error).toHaveBeenCalledTimes(1);
+    const line = String(error.mock.calls[0]?.[0]);
+    expect(line).toContain('RetryError maxRetriesExceeded');
+    expect(line).toContain('status=429');
+    expect(line).not.toContain('Пловдив');
+  });
+});

apps/web/app/lib/assistant/agent.test.ts

@@ -3,7 +3,9 @@ import { fakeD1 } from '@sigma/test-support';
 
 // agent.ts is thin Vercel-AI-SDK wiring. Mock the SDK and provider so the tests can assert the wiring
 // (model/base-URL resolution, tool-set assembly, stream Response + onError message) without a live
-// BgGPT call. resolveMaxSteps is pure and needs no mocks.
+// BgGPT call. resolveMaxSteps is pure and needs no mocks. The `ai` mock SPREADS the real module:
+// agent.ts also imports APICallError/RetryError from it for the stream-error logger, and a mock that
+// replaced the module wholesale would turn those into `undefined` and crash every onError path.
 const { streamTextMock, createOpenAIMock, chatMock } = vi.hoisted(() => {
   const chatMock = vi.fn((model: string) => ({ model }));
   return {
@@ -13,15 +15,17 @@ const { streamTextMock, createOpenAIMock, chatMock } = vi.hoisted(() => {
   };
 });
 vi.mock('@ai-sdk/openai', () => ({ createOpenAI: createOpenAIMock }));
-vi.mock('ai', () => ({
+vi.mock('ai', async (importOriginal) => ({
+  ...(await importOriginal<typeof import('ai')>()),
   convertToModelMessages: vi.fn(async (m: unknown) => m),
   jsonSchema: vi.fn((s: unknown) => s),
   stepCountIs: vi.fn((n: number) => ({ stopAt: n })),
   streamText: (o: unknown) => streamTextMock(o),
   tool: (def: unknown) => def,
 }));
 
-import { resolveMaxSteps, runAssistant } from './agent';
+import { RetryError } from 'ai';
+import { makeStreamErrorLogger, resolveMaxSteps, runAssistant, userTexts } from './agent';
 import { ASSISTANT_TOOLS } from './tools';
 
 describe('resolveMaxSteps', () => {
@@ -108,6 +112,15 @@ describe('runAssistant (SDK wiring)', () => {
     const r = await tools.emit_report.execute({ not: 'a valid report' });
     expect(r.ok).toBe(false);
     expect(Array.isArray(r.errors)).toBe(true);
+
+    // …and a valid report takes the ok branch, returning the bound (server-owned) report.
+    const ok = await tools.emit_report.execute({
+      title: 'Справка',
+      question: 'въпрос',
+      blocks: [{ type: 'text', md: 'Няма данни.' }],
+    });
+    expect(ok.ok).toBe(true);
+    expect(ok.report.title).toBe('Справка');
   });
 });
 
@@ -142,3 +155,120 @@ describe('runAssistant — the emit_report tool', () => {
     });
   });
 });
+
+describe('makeStreamErrorLogger', () => {
+  const capture = () => {
+    const lines: string[] = [];
+    const spy = vi.spyOn(console, 'error').mockImplementation((l: unknown) => {
+      lines.push(String(l));
+    });
+    return { lines, restore: () => spy.mockRestore() };
+  };
+
+  it('logs an object error once even though both stream hooks report it', () => {
+    const { lines, restore } = capture();
+    const log = makeStreamErrorLogger([]);
+    const err = new Error('провайдърът падна');
+    log(err);
+    log(err); // the second hook sees the SAME object
+    restore();
+    expect(lines).toHaveLength(1);
+    expect(lines[0]).toContain('провайдърът падна');
+  });
+
+  it('logs a PRIMITIVE throw once too — it has no identity for a WeakSet to key on', () => {
+    const { lines, restore } = capture();
+    const log = makeStreamErrorLogger([]);
+    log('низова грешка');
+    log('низова грешка');
+    restore();
+    expect(lines).toHaveLength(1);
+  });
+
+  it('still logs two DISTINCT object errors that render the same text', () => {
+    const { lines, restore } = capture();
+    const log = makeStreamErrorLogger([]);
+    log(new Error('една и съща фраза'));
+    log(new Error('една и съща фраза'));
+    restore();
+    expect(lines).toHaveLength(2);
+  });
+
+  it('tags a RetryError that wraps a NON-API error with its reason only (no status to show)', () => {
+    const { lines, restore } = capture();
+    const log = makeStreamErrorLogger([]);
+    log(
+      new RetryError({
+        message: 'опитите свършиха',
+        reason: 'errorNotRetryable',
+        errors: [new Error('мрежата падна')],
+      }),
+    );
+    restore();
+    expect(lines).toHaveLength(1);
+    expect(lines[0]).toContain('[RetryError errorNotRetryable]');
+    expect(lines[0]).not.toContain('APICallError');
+  });
+
+  it('redacts the question before it reaches the log line', () => {
+    const { lines, restore } = capture();
+    const question = 'колко плати община Пловдив на фирма Х';
+    makeStreamErrorLogger([question])(new Error(`400: ${question}`));
+    restore();
+    expect(lines[0]).not.toContain('Пловдив');
+  });
+});
+
+describe('userTexts (the redaction set for a multi-turn prompt)', () => {
+  const msgs = (parts: [string, string][]) =>
+    parts.map(([role, text]) => ({
+      role,
+      parts: [{ type: 'text', text }],
+    })) as unknown as Parameters<typeof userTexts>[0];
+
+  it('collects EVERY user turn, not just the latest', () => {
+    // A provider error can quote back any part of the prompt, and a multi-turn prompt carries the
+    // earlier questions too — redacting only ctx.userQuestion left those in the tail log (review f/u).
+    const earlier = 'колко плати община Пловдив през 2023';
+    const latest = 'а през 2024 колко плати същата община';
+    expect(
+      userTexts(
+        msgs([
+          ['user', earlier],
+          ['assistant', 'отговор'],
+          ['user', latest],
+        ]),
+      ),
+    ).toEqual([earlier, latest]);
+  });
+
+  it("ignores non-user roles and empty texts (they are not the person's words)", () => {
+    expect(
+      userTexts(
+        msgs([
+          ['assistant', 'наш текст'],
+          ['user', '   '],
+          ['system', 'директива'],
+        ]),
+      ),
+    ).toEqual([]);
+  });
+
+  it('feeds the logger a set that blanks an EARLIER question', () => {
+    const lines: string[] = [];
+    const spy = vi.spyOn(console, 'error').mockImplementation((l: unknown) => {
+      lines.push(String(l));
+    });
+    const earlier = 'колко плати община Пловдив през 2023';
+    const set = userTexts(
+      msgs([
+        ['user', earlier],
+        ['user', 'а през 2024 колко плати същата община'],
+      ]),
+    );
+    makeStreamErrorLogger(set)(new Error(`400 invalid input: ${earlier}`));
+    spy.mockRestore();
+    expect(lines[0]).not.toContain('Пловдив');
+    expect(lines[0]).toContain('«редактирано»');
+  });
+});