testeiya 0.2.0

package/src/context-store.ts

@@ -0,0 +1,265 @@
+import fs from "node:fs";
+import path from "node:path";
+import dedent from "dedent";
+import {
+  PROJECT_DIR,
+  CONTEXT_CODE_SUBDIR,
+  CONTEXT_REQUIREMENTS_SUBDIR,
+  MANUAL_TESTS_SUBDIR,
+  contextManifestPath,
+  ensureProjectDirGuards,
+} from "./project-dir.js";
+
+/**
+ * Workspace context: extra resources attached to a workspace so the agent can
+ * consult them — symlinked local folders and shallow-cloned git repos (both
+ * directly under `.testeiya/<name>`, named after the source) and documents
+ * (under `.testeiya/requirements/` and `.testeiya/docs/`). The manifest
+ * (`.testeiya/context.json`) records what the user added via the UI;
+ * `listContext` folds in anything else found in the legacy `.testeiya/code/`
+ * dir (e.g. put there by the agent itself), so the system prompt and the chat
+ * status bar always reflect the real folder contents.
+ */
+
+/** Extra doc dir the agent writes on its own (see the system prompt's context structure). */
+const CONTEXT_DOCS_SUBDIR = "docs";
+
+/**
+ * The predefined `.testeiya` context structure — mirrors the system prompt's
+ * <context-workspace> section. Only these are surfaced as status-bar sections;
+ * anything else inside `.testeiya` (uploads, skills, ad-hoc agent dirs) is
+ * plumbing, not context. User-added entries (linked folders, cloned repos)
+ * live directly under `.testeiya/<name>` and must never shadow these names.
+ */
+export const CONTEXT_SECTION_DIRS = [
+  MANUAL_TESTS_SUBDIR,
+  CONTEXT_CODE_SUBDIR,
+  CONTEXT_REQUIREMENTS_SUBDIR,
+  CONTEXT_DOCS_SUBDIR,
+  "auto-tests",
+  "exploratory",
+];
+
+/** The non-empty predefined context folders, one status-bar section each. */
+export function listContextFolders(cwd: string): ContextFolder[] {
+  const folders: ContextFolder[] = [];
+  for (const name of CONTEXT_SECTION_DIRS) {
+    const count = readdirSafe(path.join(cwd, PROJECT_DIR, name)).filter(
+      (e) => !e.name.startsWith(".")
+    ).length;
+    if (count === 0) continue;
+    folders.push({ name, path: `${PROJECT_DIR}/${name}`, count });
+  }
+  return folders;
+}
+
+/** Every context entry: the manifest plus items discovered on disk. */
+export function listContext(cwd: string): ContextEntry[] {
+  const manifest = loadContextEntries(cwd);
+  const known = new Set(manifest.map((e) => e.path));
+  const discovered: ContextEntry[] = [];
+  discoverDirs(cwd, CONTEXT_CODE_SUBDIR, known, discovered);
+  discoverFiles(cwd, CONTEXT_REQUIREMENTS_SUBDIR, known, discovered);
+  discoverFiles(cwd, CONTEXT_DOCS_SUBDIR, known, discovered);
+  return [...manifest, ...discovered];
+}
+
+export function loadContextEntries(cwd: string): ContextEntry[] {
+  let raw: { entries?: ContextEntry[] };
+  try {
+    raw = JSON.parse(fs.readFileSync(contextManifestPath(cwd), "utf8"));
+  } catch {
+    return [];
+  }
+  const entries = Array.isArray(raw.entries) ? raw.entries : [];
+  return entries.filter((e) => e?.path && exists(path.join(cwd, e.path)));
+}
+
+export function saveContextEntries(cwd: string, entries: ContextEntry[]): void {
+  const dir = path.join(cwd, PROJECT_DIR);
+  fs.mkdirSync(dir, { recursive: true });
+  ensureProjectDirGuards(cwd);
+  fs.writeFileSync(
+    contextManifestPath(cwd),
+    JSON.stringify({ entries, updatedAt: new Date().toISOString() }, null, 2)
+  );
+}
+
+/**
+ * Change marker for the workspace context: the manifest mtime plus the set of
+ * non-empty predefined folders (so a mid-session pull that seeds
+ * `manual-tests` also registers as a change). "" when nothing exists.
+ */
+export function contextStamp(cwd: string): string {
+  let mtime = 0;
+  try {
+    mtime = fs.statSync(contextManifestPath(cwd)).mtimeMs;
+  } catch {
+    // no manifest yet
+  }
+  const names = listContextFolders(cwd).map((f) => f.name);
+  return `${mtime}|${names.join(",")}`;
+}
+
+/** System-prompt section describing the workspace context; "" when none. */
+export function contextPromptSection(
+  entries: ContextEntry[],
+  folders: ContextFolder[] = []
+): string {
+  if (entries.length === 0 && folders.length === 0) return "";
+  return dedent`
+  <workspace-context>
+    This workspace has context attached — the user (or you, earlier) put it there for a purpose. Consult it before answering, and prefer it over assumptions about the project.
+
+  ${contextLines(entries, folders)}
+
+    ALL of it lives under the hidden \`${PROJECT_DIR}/\` dir: file-search tools skip hidden dirs by default, so search it explicitly (pass hidden:true, or prefix the path with \`${PROJECT_DIR}/\`). Linked folders and cloned repositories are reference material: read them, never modify them. A linked folder is a symlink — wildcard searches do not descend into it; search it with its own path prefix (e.g. \`${PROJECT_DIR}/<name>/\`). Documents under \`${PROJECT_DIR}/requirements\` and \`${PROJECT_DIR}/docs\` are specs and plans — use them when writing or reviewing tests.
+  </workspace-context>
+  `;
+}
+
+/** Per-prompt notice when the context changed mid-session; appended to the next prompt. */
+export function contextUpdateNotice(
+  entries: ContextEntry[],
+  folders: ContextFolder[] = []
+): string {
+  if (entries.length === 0 && folders.length === 0) {
+    return dedent`
+    <workspace-context-update>
+      All extra workspace context was removed. Do not rely on it anymore.
+    </workspace-context-update>
+    `;
+  }
+  return dedent`
+  <workspace-context-update>
+    The workspace context just changed. It now contains:
+
+  ${contextLines(entries, folders)}
+
+    This was done for a purpose — take it into account for this and future requests. Remember \`${PROJECT_DIR}/\` is hidden: search it with hidden:true or an explicit path prefix.
+  </workspace-context-update>
+  `;
+}
+
+function contextLines(entries: ContextEntry[], folders: ContextFolder[]): string {
+  const lines: string[] = [];
+  const covered = new Set(entries.map((e) => parentDir(e.path)));
+  for (const f of folders) {
+    if (covered.has(f.path)) continue;
+    lines.push(`- \`${f.path}/\` — ${folderPurpose(f.name)}`);
+  }
+  for (const e of entries) lines.push(`- ${describeEntry(e)}`);
+  return lines.join("\n");
+}
+
+function folderPurpose(name: string): string {
+  if (name === "manual-tests") {
+    return "the project's manual test suites pulled from Testomat.io (*.test.md — THE manual tests of this project)";
+  }
+  if (name === "code") return "reference code added as context";
+  if (name === "requirements") return "requirements and specs";
+  if (name === "docs") return "test planning and strategy documents";
+  if (name === "auto-tests") return "automated test references";
+  return "exploratory testing setup";
+}
+
+function parentDir(rel: string): string {
+  const idx = rel.lastIndexOf("/");
+  if (idx < 0) return "";
+  return rel.slice(0, idx);
+}
+
+function describeEntry(e: ContextEntry): string {
+  const date = e.addedAt?.split("T")[0] ?? "";
+  let from = "";
+  if (e.origin && e.origin !== e.name) from = ` from ${e.origin}`;
+  if (e.kind === "repo") return `\`${e.path}\` — git repository${from} (${date})`;
+  if (e.kind === "folder") return `\`${e.path}\` — local folder${from} (${date})`;
+  return `\`${e.path}\` — document${from} (${date})`;
+}
+
+// Top-level dirs in `.testeiya/code` not in the manifest: `folder` entries, or
+// `repo` when they carry their own `.git` (a clone made by the agent).
+function discoverDirs(
+  cwd: string,
+  subdir: string,
+  known: Set<string>,
+  out: ContextEntry[]
+): void {
+  for (const entry of readdirSafe(path.join(cwd, PROJECT_DIR, subdir))) {
+    if (!entry.isDirectory() && !entry.isSymbolicLink()) continue;
+    const rel = `${PROJECT_DIR}/${subdir}/${entry.name}`;
+    if (known.has(rel)) continue;
+    let kind: ContextKind = "folder";
+    if (!entry.isSymbolicLink() && fs.existsSync(path.join(cwd, rel, ".git"))) kind = "repo";
+    out.push(discoveredEntry(cwd, kind, entry.name, rel));
+  }
+}
+
+function discoverFiles(
+  cwd: string,
+  subdir: string,
+  known: Set<string>,
+  out: ContextEntry[]
+): void {
+  for (const entry of readdirSafe(path.join(cwd, PROJECT_DIR, subdir))) {
+    if (!entry.isFile() || entry.name.startsWith(".")) continue;
+    const rel = `${PROJECT_DIR}/${subdir}/${entry.name}`;
+    if (known.has(rel)) continue;
+    out.push(discoveredEntry(cwd, "file", entry.name, rel));
+  }
+}
+
+function discoveredEntry(
+  cwd: string,
+  kind: ContextKind,
+  name: string,
+  rel: string
+): ContextEntry {
+  let addedAt = "";
+  try {
+    addedAt = fs.lstatSync(path.join(cwd, rel)).mtime.toISOString();
+  } catch {
+    // keep empty — the entry is still listable
+  }
+  return { id: `fs:${rel}`, kind, name, path: rel, origin: "", addedAt };
+}
+
+function readdirSafe(dir: string): fs.Dirent[] {
+  try {
+    return fs.readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+}
+
+function exists(p: string): boolean {
+  try {
+    fs.lstatSync(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export type ContextKind = "folder" | "repo" | "file";
+
+/** A top-level `.testeiya` folder shown as a status-bar section. */
+export interface ContextFolder {
+  name: string;
+  /** Relative to cwd (`.testeiya/<name>`). */
+  path: string;
+  /** Direct children (files + dirs, dot entries excluded). */
+  count: number;
+}
+
+export interface ContextEntry {
+  id: string;
+  kind: ContextKind;
+  name: string;
+  /** Location inside the workspace, relative to cwd (always under `.testeiya/`). */
+  path: string;
+  /** Where it came from: an absolute local path, a git URL, or the uploaded filename. */
+  origin: string;
+  addedAt: string;
+}

package/src/debug-bus.ts

@@ -0,0 +1,405 @@
+import { appendFileSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { log, type WideEvent } from "evlog";
+import { readMemoryLogs } from "evlog/memory";
+
+/*
+ * Server-side instrumentation for the sidebar Debug panel, built on the evlog
+ * pipeline that `file-log.ts` initializes. The real outbound calls to the
+ * Testomat.io API server happen here in the Bun process (the v2 proxy,
+ * attachment upload, transcription) — the browser only ever sees the
+ * same-origin `/api/testomatio/*` proxy hop. `loggedServerFetch` (and
+ * `publish` for the `ai` / `check-tests` channels) emits one evlog wide event
+ * per call; the shared drain fans it out to the NDJSON app log, the in-memory
+ * ring buffer (`evlog/memory` — the snapshot's source), and `panelDrain`
+ * below, which maps panel-facing channels onto the `DebugEntry` wire shapes
+ * the `/api/debug/stream` SSE feed and the client panel already speak.
+ *
+ * While debug mode is on — the panel is open (an SSE subscriber is connected)
+ * or `TESTEIYA_DEBUG=1` is set — each request + response is also appended to
+ * `cli/log/testomatio.http` (gitignored) as a re-runnable `.http` block
+ * (VS Code REST Client / JetBrains), with the response captured as trailing
+ * comments so the agent can verify the REST API. The file includes the
+ * `Authorization` header so requests actually replay; that token never reaches
+ * the panel or the SSE feed.
+ */
+
+const MAX_BODY = 16000;
+const FILE_RESPONSE_MAX = 6000;
+const LOG_DIR = fileURLToPath(new URL("../log", import.meta.url));
+const REPLAY_FILE = join(LOG_DIR, "testomatio.http");
+
+let panelSeq = 0;
+let dirReady = false;
+let latestReportKey: string | null = null;
+const clientReports = new Map<string, ClientReport>();
+const subscribers = new Set<(entry: DebugEntry) => void>();
+
+export async function loggedServerFetch(
+  url: string,
+  init: RequestInit,
+  requestBody?: string | null
+): Promise<{ res: Response; text: string }> {
+  const method = (init.method ?? "GET").toUpperCase();
+  const started = Date.now();
+  try {
+    const res = await fetch(url, init);
+    const text = await res.text();
+    record(
+      {
+        method,
+        url,
+        requestBody: requestBody ?? null,
+        status: res.status,
+        ok: res.ok,
+        responseBody: text,
+        error: null,
+        durationMs: Date.now() - started,
+      },
+      init.headers
+    );
+    return { res, text };
+  } catch (e) {
+    if ((e as { name?: string })?.name === "AbortError") throw e;
+    record(
+      {
+        method,
+        url,
+        requestBody: requestBody ?? null,
+        status: null,
+        ok: false,
+        responseBody: null,
+        error: e instanceof Error ? e.message : String(e),
+        durationMs: Date.now() - started,
+      },
+      init.headers
+    );
+    throw e;
+  }
+}
+
+/**
+ * Record a `check-tests` subprocess run (pull/push) as a Debug-panel event so its
+ * outcome + full output are visible alongside requests — the same feed the panel
+ * already renders, so an exit-1 sync stops being a silent "[check-tests] exited 1".
+ */
+export function publishCheckTests(run: {
+  action: string;
+  dir: string;
+  code: number | null;
+  output: string;
+  durationMs: number;
+}): void {
+  publish({
+    kind: "event",
+    channel: "check-tests",
+    name: `check-tests ${run.action}`,
+    summary: `${run.code === 0 ? "ok" : `exit ${run.code}`} · ${run.dir} · ${run.durationMs}ms`,
+    ok: run.code === 0,
+    detail: truncate(run.output),
+  });
+}
+
+export function subscribeDebug(cb: (entry: DebugEntry) => void): () => void {
+  subscribers.add(cb);
+  return () => {
+    subscribers.delete(cb);
+  };
+}
+
+export function recentDebugEntries(): DebugEntry[] {
+  return readMemoryLogs()
+    .map(toPanelEntry)
+    .filter((entry): entry is DebugEntry => !!entry);
+}
+
+/*
+ * Latest client debug report per session — the browser's unified activity log
+ * (`api` + `agent` + `console` channels) plus a MobX store snapshot, pushed via
+ * `POST /api/debug/report`. Keyed by session so a snapshot request can pick the
+ * matching one; `latestReportKey` is the fallback when no session is given.
+ */
+export function recordClientReport(report: ClientReport): void {
+  const key = report.sessionId || "default";
+  clientReports.set(key, report);
+  latestReportKey = key;
+}
+
+export function buildSnapshot(sessionId?: string | null): DebugSnapshot {
+  const events = readMemoryLogs();
+  const entries = events.map(toPanelEntry);
+  return {
+    generatedAt: new Date().toISOString(),
+    server: {
+      requests: entries.filter((e): e is ServerRequestEntry => !!e && e.kind === "request"),
+      ai: entries.filter((e): e is AiEventEntry => !!e && e.kind === "ai"),
+      checkTests: entries.filter((e): e is ProcessEventEntry => !!e && e.kind === "event"),
+      console: events.filter((e) => e.tag === "console").map(toConsoleEntry),
+      api: events.filter((e) => e.channel === "api"),
+      prompts: events.filter((e) => e.channel === "prompt"),
+    },
+    client: getClientReport(sessionId),
+    langfuseHint: "bun run debug:trace session:<agent-conversation-id>",
+  };
+}
+
+export function clientLayout(
+  sessionId?: string | null
+): { layout: unknown; reportedAt: string | null; url: string | null } | null {
+  const report = getClientReport(sessionId);
+  if (!report) return null;
+  let url: string | null = null;
+  const meta = report.meta as { url?: unknown } | null;
+  if (meta && typeof meta.url === "string") url = meta.url;
+  return { layout: report.layout ?? null, reportedAt: report.reportedAt, url };
+}
+
+/*
+ * Generic sink for any non-request debug entry (currently the `ai` channel —
+ * pi-coding-agent LLM interactions; see `ai-debug.ts`). Emits an evlog wide
+ * event, which the shared drain routes to the file/memory sinks and back into
+ * `panelDrain` for the live SSE feed.
+ */
+export function publish(entry: WithoutMeta<DebugEntry>): void {
+  const { kind: _, ...fields } = entry;
+  if (entry.ok) {
+    log.info(fields);
+    return;
+  }
+  log.error(fields);
+}
+
+/**
+ * Drain hook wired into the evlog pipeline by `file-log.ts`: maps panel-facing
+ * wide events onto the `DebugEntry` wire shapes and pushes them to the live
+ * SSE subscribers. Non-panel channels (`api`, `prompt`, `console`) stay in the
+ * file/memory sinks only.
+ */
+export function panelDrain(event: WideEvent): void {
+  const entry = toPanelEntry(event);
+  if (!entry) return;
+  for (const cb of subscribers) cb(entry);
+}
+
+function getClientReport(sessionId?: string | null): ClientReport | null {
+  if (sessionId && clientReports.has(sessionId)) return clientReports.get(sessionId)!;
+  if (latestReportKey) return clientReports.get(latestReportKey) ?? null;
+  return null;
+}
+
+function toPanelEntry(event: WideEvent): DebugEntry | null {
+  const e = event as Record<string, any>;
+  const channel = e.channel;
+  if (channel !== "testomatio" && channel !== "ai" && channel !== "check-tests") return null;
+  if (!e._panelId) {
+    panelSeq += 1;
+    e._panelId = panelSeq;
+  }
+  const id = e._panelId as number;
+  const ts = Date.parse(e.timestamp) || Date.now();
+  if (channel === "testomatio") {
+    return {
+      kind: "request",
+      channel: "testomatio",
+      id,
+      ts,
+      method: e.method,
+      url: e.url,
+      requestBody: e.requestBody ?? null,
+      status: e.status ?? null,
+      ok: !!e.ok,
+      responseBody: e.responseBody ?? null,
+      error: e.error ?? null,
+      durationMs: e.durationMs ?? 0,
+    };
+  }
+  if (channel === "ai") {
+    return {
+      kind: "ai",
+      channel: "ai",
+      id,
+      ts,
+      name: e.name,
+      summary: e.summary ?? null,
+      ok: !!e.ok,
+      model: e.model ?? null,
+      durationMs: e.durationMs ?? null,
+      tokens: e.tokens ?? null,
+      detail: e.detail ?? null,
+    };
+  }
+  return {
+    kind: "event",
+    channel: "check-tests",
+    id,
+    ts,
+    name: e.name,
+    summary: e.summary ?? null,
+    ok: !!e.ok,
+    detail: e.detail ?? null,
+  };
+}
+
+function toConsoleEntry(event: WideEvent): ServerConsoleEntry {
+  let level: ServerConsoleEntry["level"] = "log";
+  if (event.level === "warn") level = "warn";
+  if (event.level === "error") level = "error";
+  return {
+    level,
+    ts: Date.parse(event.timestamp) || 0,
+    text: String((event as Record<string, unknown>).message ?? ""),
+  };
+}
+
+function record(partial: RequestData, headers?: HeadersInit): void {
+  const outcome = partial.error ?? partial.status ?? "—";
+  console.log(
+    `[testomatio→] ${partial.method} ${partial.url} → ${outcome} (${partial.durationMs}ms)`
+  );
+  const event = {
+    channel: "testomatio",
+    ...partial,
+    requestBody: truncate(partial.requestBody),
+    responseBody: truncate(partial.responseBody),
+  };
+  if (partial.ok) log.info(event);
+  else log.error(event);
+  writeReplayFile(partial, headers);
+}
+
+function writeReplayFile(data: RequestData, headers?: HeadersInit): void {
+  if (subscribers.size === 0 && process.env.TESTEIYA_DEBUG !== "1") return;
+  try {
+    if (!dirReady) {
+      mkdirSync(LOG_DIR, { recursive: true });
+      dirReady = true;
+    }
+    appendFileSync(REPLAY_FILE, formatHttp(data, headers));
+  } catch {}
+}
+
+function formatHttp(data: RequestData, headers?: HeadersInit): string {
+  const ts = new Date().toISOString();
+  const resource = data.url.replace(/\?.*$/, "").split("/").pop() || data.url;
+  const outcome = data.error ? `ERR ${data.error}` : data.status;
+  const lines = [
+    `### ${data.method} ${resource} — ${ts} → ${outcome} (${data.durationMs}ms)`,
+    `${data.method} ${data.url}`,
+  ];
+  for (const [key, value] of headerEntries(headers)) lines.push(`${key}: ${value}`);
+  if (data.requestBody && data.requestBody.startsWith("[multipart]")) {
+    lines.push(`# ${data.requestBody} (binary body not captured)`);
+  }
+  if (data.requestBody && !data.requestBody.startsWith("[multipart]")) {
+    lines.push("", data.requestBody);
+  }
+  lines.push("", ...responseComment(data), "", "");
+  return lines.join("\n");
+}
+
+function responseComment(data: RequestData): string[] {
+  if (data.error) return [`# ── error: ${data.error} ──`];
+  const head = `# ── response ${data.status} (${data.durationMs}ms) ──`;
+  if (!data.responseBody) return [head];
+  let body = data.responseBody;
+  if (body.length > FILE_RESPONSE_MAX) {
+    body = `${body.slice(0, FILE_RESPONSE_MAX)}… (truncated)`;
+  }
+  return [head, ...body.split("\n").map((line) => `# ${line}`)];
+}
+
+function headerEntries(headers?: HeadersInit): [string, string][] {
+  if (!headers) return [];
+  if (headers instanceof Headers) return [...headers.entries()];
+  if (Array.isArray(headers)) return headers as [string, string][];
+  return Object.entries(headers);
+}
+
+function truncate(value: string | null): string | null {
+  if (!value) return value;
+  if (value.length <= MAX_BODY) return value;
+  return `${value.slice(0, MAX_BODY)}… (+${value.length - MAX_BODY} more chars)`;
+}
+
+type RequestData = Omit<ServerRequestEntry, "id" | "ts" | "kind" | "channel">;
+
+// Distributes over the union so each member keeps its own keys (a plain
+// `Omit<A | B, K>` collapses to only the keys common to A and B).
+type WithoutMeta<T> = T extends unknown ? Omit<T, "id" | "ts"> : never;
+
+export interface ServerRequestEntry {
+  kind: "request";
+  channel: "testomatio";
+  id: number;
+  ts: number;
+  method: string;
+  url: string;
+  requestBody: string | null;
+  status: number | null;
+  ok: boolean;
+  responseBody: string | null;
+  error: string | null;
+  durationMs: number;
+}
+
+// Mirrors `AiLogEntry` in `lib/debug/external-log.ts` so entries ride the SSE
+// feed straight into the panel's `record()`.
+export interface AiEventEntry {
+  kind: "ai";
+  channel: "ai";
+  id: number;
+  ts: number;
+  name: string;
+  summary: string | null;
+  ok: boolean;
+  model: string | null;
+  durationMs: number | null;
+  tokens: { input: number; output: number; total: number } | null;
+  detail: string | null;
+}
+
+// A `check-tests` subprocess run, shaped to match the client's `EventLogEntry`
+// so it rides the SSE feed straight into the panel's event rows.
+export interface ProcessEventEntry {
+  kind: "event";
+  channel: "check-tests";
+  id: number;
+  ts: number;
+  name: string;
+  summary: string | null;
+  ok: boolean;
+  detail: string | null;
+}
+
+export type DebugEntry = ServerRequestEntry | AiEventEntry | ProcessEventEntry;
+
+export interface ServerConsoleEntry {
+  level: "log" | "warn" | "error";
+  ts: number;
+  text: string;
+}
+
+export interface ClientReport {
+  sessionId: string | null;
+  reason: string;
+  reportedAt: string;
+  entries: unknown[];
+  store: unknown;
+  meta: unknown;
+  layout?: unknown;
+}
+
+export interface DebugSnapshot {
+  generatedAt: string;
+  server: {
+    requests: ServerRequestEntry[];
+    ai: AiEventEntry[];
+    checkTests: ProcessEventEntry[];
+    console: ServerConsoleEntry[];
+    api: WideEvent[];
+    prompts: WideEvent[];
+  };
+  client: ClientReport | null;
+  langfuseHint: string;
+}