failproofai 1.0.7-beta.1 → 1.0.7-beta.2

package/.next/standalone/sdk/typescript/integration/fixtures/mastra-1/package.json

@@ -0,0 +1,15 @@
+{
+  "name": "failproofai-it-mastra-1",
+  "private": true,
+  "type": "module",
+  "description": "Integration fixture: Mastra 1.x (@mastra/core) against the packed @failproofai/sdk.",
+  "dependencies": {
+    "@mastra/core": "1.68.0",
+    "@mastra/mcp": "2.0.0",
+    "@mastra/memory": "1.31.0",
+    "zod": "4.6.5"
+  },
+  "devDependencies": {
+    "@types/node": "22.20.4"
+  }
+}

package/.next/standalone/sdk/typescript/integration/fixtures/mastra-1/tsconfig.json

@@ -0,0 +1,12 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "nodenext",
+    "moduleResolution": "nodenext",
+    "strict": true,
+    "noEmit": true,
+    "skipLibCheck": true,
+    "types": ["node"]
+  },
+  "files": ["agent.ts"]
+}

package/.next/standalone/sdk/typescript/integration/fixtures/nextjs/app/actions.ts

@@ -0,0 +1,18 @@
+"use server";
+
+import { telemetry } from "@failproofai/sdk/ai";
+import { generateText } from "ai";
+
+import { loop, scripted, tools } from "../lib/ai";
+
+/** A server action running an agent (twin: ai-7 `generate`). */
+export async function askWeather(): Promise<string> {
+  const { text } = await generateText({
+    model: scripted(),
+    prompt: "Weather in Paris?",
+    tools: tools(),
+    ...loop,
+    experimental_telemetry: telemetry({ functionId: "weather-agent" }),
+  });
+  return text;
+}

package/.next/standalone/sdk/typescript/integration/fixtures/nextjs/app/api/ai/route.ts

@@ -0,0 +1,42 @@
+import { telemetry } from "@failproofai/sdk/ai";
+import { generateText, streamText } from "ai";
+
+import { loop, scripted, tools } from "../../../lib/ai";
+
+export const dynamic = "force-dynamic";
+
+/**
+ * `?mode=telemetry`          generateText, call-site `telemetry()`       (twin: ai-7 `generate`)
+ * `?mode=instrument`         generateText, `instrument()` + isEnabled     (twin: ai-7 `instrument`)
+ * `?mode=stream`             streamText → toUIMessageStreamResponse(),
+ *                            call-site `telemetry()`                      (twin: ai-7 `stream`)
+ * `?mode=instrument-stream`  the same through `instrument()`             (twin: ai-7 `instrument-stream`)
+ *
+ * The streaming modes return the stream itself, as a chat route does: the
+ * model is still producing when the handler returns.
+ */
+export async function GET(request: Request): Promise<Response> {
+  const mode = new URL(request.url).searchParams.get("mode") ?? "telemetry";
+  const viaInstrument = mode.startsWith("instrument");
+  const settings = viaInstrument
+    ? { isEnabled: true as const, functionId: "weather-agent" }
+    : telemetry({ functionId: "weather-agent" });
+  if (mode.endsWith("stream")) {
+    const result = streamText({
+      model: scripted(),
+      prompt: "Weather in Rome?",
+      tools: tools(),
+      ...loop,
+      experimental_telemetry: settings,
+    });
+    return result.toUIMessageStreamResponse();
+  }
+  const { text } = await generateText({
+    model: scripted(),
+    prompt: "Weather in Paris?",
+    tools: tools(),
+    ...loop,
+    experimental_telemetry: settings,
+  });
+  return Response.json({ text });
+}

package/.next/standalone/sdk/typescript/integration/fixtures/nextjs/app/api/edge/route.ts

@@ -0,0 +1,29 @@
+import * as failproofai from "@failproofai/sdk";
+
+export const runtime = "edge";
+export const dynamic = "force-dynamic";
+
+/**
+ * The SDK in the Edge runtime: no filesystem, so no spool. Importing it must
+ * not take the route down; what each call does instead is what this reports.
+ */
+export async function GET(): Promise<Response> {
+  const outcome: Record<string, unknown> = { imported: typeof failproofai.event === "object" };
+  try {
+    failproofai.session({ sessionId: "edge-session" }, () =>
+      failproofai.agent("edge-agent", () => {
+        failproofai.event.modelRequest({ model: "mock-model", requestId: "r-1" });
+      }),
+    );
+    outcome.emitted = true;
+  } catch (error) {
+    outcome.emitted = String(error);
+  }
+  try {
+    await failproofai.flush();
+    outcome.flushed = true;
+  } catch (error) {
+    outcome.flushed = String(error);
+  }
+  return Response.json(outcome);
+}

package/.next/standalone/sdk/typescript/integration/fixtures/nextjs/app/api/langgraph/route.ts

@@ -0,0 +1,21 @@
+import { langchainHandler } from "@failproofai/sdk/langchain";
+
+import { ScriptedModel, buildGraph, question } from "../../../lib/langgraph";
+
+export const dynamic = "force-dynamic";
+
+/**
+ * `?mode=instrument` — relies on `instrument()` from instrumentation.ts
+ *                      (twin: langchain-1 `graph`).
+ * `?mode=handler`    — passes the call-site handler, no patching
+ *                      (twin: langchain-1 `handler`).
+ */
+export async function GET(request: Request): Promise<Response> {
+  const mode = new URL(request.url).searchParams.get("mode") ?? "instrument";
+  const graph = buildGraph(new ScriptedModel());
+  const out =
+    mode === "handler"
+      ? await graph.invoke(question(), { callbacks: [langchainHandler() as never] })
+      : await graph.invoke(question());
+  return Response.json({ answer: out.messages.at(-1)?.content });
+}

package/.next/standalone/sdk/typescript/integration/fixtures/nextjs/app/api/llamaindex/route.ts

@@ -0,0 +1,11 @@
+import { agent } from "@llamaindex/workflow";
+
+import { QUESTION, ScriptedLLM, getWeather } from "../../../lib/llamaindex";
+
+export const dynamic = "force-dynamic";
+
+/** A LlamaIndex agent workflow through `instrument()` (twin: llamaindex-0.12 `workflow`). */
+export async function GET(): Promise<Response> {
+  const out = await agent({ llm: new ScriptedLLM(), tools: [getWeather] }).run(QUESTION);
+  return Response.json({ answer: out.data.result });
+}

package/.next/standalone/sdk/typescript/integration/fixtures/nextjs/app/api/mastra/route.ts

@@ -0,0 +1,19 @@
+import { wrapTool } from "@failproofai/sdk/mastra";
+
+import { question, weather, weatherAgent } from "../../../lib/mastra";
+
+export const dynamic = "force-dynamic";
+
+/**
+ * `?mode=instrument` — Agent.generate() through `instrument()` (twin: mastra-1 `generate`).
+ * `?mode=wraptool`   — the call-site `wrapTool()`               (twin: mastra-1 `wraptool`).
+ */
+export async function GET(request: Request): Promise<Response> {
+  const mode = new URL(request.url).searchParams.get("mode") ?? "instrument";
+  if (mode === "wraptool") {
+    const tool = wrapTool(weather);
+    return Response.json({ out: await tool.execute!({ city: "Rome" }, {} as never) });
+  }
+  const out = await weatherAgent().generate(question);
+  return Response.json({ answer: out.text });
+}

package/.next/standalone/sdk/typescript/integration/fixtures/nextjs/app/api/status/route.ts

@@ -0,0 +1,7 @@
+export const dynamic = "force-dynamic";
+
+/** What instrumentation.ts's `instrument()` returned, and whether it ran at all. */
+export function GET(): Response {
+  const instrumented = (globalThis as { __failproofaiInstrumented?: string[] }).__failproofaiInstrumented ?? null;
+  return Response.json({ instrumented, runtime: process.env.NEXT_RUNTIME ?? null });
+}

package/.next/standalone/sdk/typescript/integration/fixtures/nextjs/app/layout.tsx

@@ -0,0 +1,9 @@
+import type { ReactNode } from "react";
+
+export default function RootLayout({ children }: { children: ReactNode }) {
+  return (
+    <html lang="en">
+      <body>{children}</body>
+    </html>
+  );
+}

package/.next/standalone/sdk/typescript/integration/fixtures/nextjs/app/page.tsx

@@ -0,0 +1,15 @@
+import { askWeather } from "./actions";
+
+export const dynamic = "force-dynamic";
+
+export default function Page() {
+  async function submit(): Promise<void> {
+    "use server";
+    await askWeather();
+  }
+  return (
+    <form action={submit}>
+      <button type="submit">Ask</button>
+    </form>
+  );
+}

package/.next/standalone/sdk/typescript/integration/fixtures/nextjs/instrumentation.ts

@@ -0,0 +1,15 @@
+/**
+ * Next.js's documented startup hook: `register()` runs once per server process,
+ * before any request is handled. The place the README should tell Next users
+ * to call `instrument()`.
+ *
+ * `NEXT_RUNTIME` guards the Node-only work: Next also evaluates this file for
+ * the Edge runtime, where the SDK has no filesystem to spool to.
+ */
+export async function register(): Promise<void> {
+  if (process.env.NEXT_RUNTIME !== "nodejs") return;
+  if (process.env.FAILPROOFAI_IT_INSTRUMENT === "0") return;
+  const failproofai = await import("@failproofai/sdk");
+  const instrumented = await failproofai.instrument();
+  (globalThis as { __failproofaiInstrumented?: string[] }).__failproofaiInstrumented = instrumented;
+}

package/.next/standalone/sdk/typescript/integration/fixtures/nextjs/lib/ai.ts

@@ -0,0 +1,61 @@
+// The ai-7 fixture's scripted model and tool, verbatim, so a route's trace can
+// be compared with that fixture's trace under plain Node.
+import { simulateReadableStream, stepCountIs, tool } from "ai";
+import { MockLanguageModelV4 } from "ai/test";
+import { z } from "zod";
+
+type StreamPart = Awaited<ReturnType<MockLanguageModelV4["doStream"]>>["stream"] extends ReadableStream<infer P> ? P : never;
+
+const usage = (input: number, output: number) => ({
+  inputTokens: { total: input, noCache: input, cacheRead: undefined, cacheWrite: undefined },
+  outputTokens: { total: output, text: output, reasoning: undefined },
+});
+const finish = (reason: "stop" | "tool-calls") => ({ unified: reason, raw: reason });
+
+export function scripted() {
+  let generated = 0;
+  let streamed = 0;
+  return new MockLanguageModelV4({
+    provider: "mock-provider",
+    modelId: "mock-model",
+    doGenerate: async () => {
+      generated += 1;
+      if (generated === 1) {
+        return {
+          content: [{ type: "tool-call", toolCallId: "call-1", toolName: "weather", input: '{"city":"Paris"}' }],
+          finishReason: finish("tool-calls"),
+          usage: usage(11, 7),
+          warnings: [],
+        };
+      }
+      return { content: [{ type: "text", text: "It is 20C in Paris." }], finishReason: finish("stop"), usage: usage(23, 9), warnings: [] };
+    },
+    doStream: async () => {
+      streamed += 1;
+      const text = (id: string, ...deltas: string[]): StreamPart[] => [
+        { type: "text-start", id },
+        ...deltas.map((delta): StreamPart => ({ type: "text-delta", id, delta })),
+        { type: "text-end", id },
+      ];
+      const chunks: StreamPart[] =
+        streamed === 1
+          ? [
+              { type: "stream-start", warnings: [] },
+              { type: "tool-call", toolCallId: "call-s1", toolName: "weather", input: '{"city":"Rome"}' },
+              { type: "finish", finishReason: finish("tool-calls"), usage: usage(13, 4) },
+            ]
+          : [{ type: "stream-start", warnings: [] }, ...text("t", "Rome is ", "25C."), { type: "finish", finishReason: finish("stop"), usage: usage(30, 6) }];
+      return { stream: simulateReadableStream({ chunks }) };
+    },
+  });
+}
+
+export const tools = () => ({
+  weather: tool({
+    description: "Current weather for a city",
+    inputSchema: z.object({ city: z.string() }),
+    execute: async ({ city }: { city: string }) => ({ city, celsius: city === "Paris" ? 20 : 25 }),
+  }),
+});
+
+export const loop = { stopWhen: stepCountIs(4) };

package/.next/standalone/sdk/typescript/integration/fixtures/nextjs/lib/langgraph.ts

@@ -0,0 +1,68 @@
+// The langchain-1 fixture's graph and scripted model, verbatim, so a route's
+// trace can be compared with that fixture's trace under plain Node.
+import { BaseChatModel, type BaseChatModelParams } from "@langchain/core/language_models/chat_models";
+import { AIMessage, HumanMessage, type BaseMessage } from "@langchain/core/messages";
+import type { ChatResult } from "@langchain/core/outputs";
+import { tool } from "@langchain/core/tools";
+import { END, MessagesAnnotation, START, StateGraph } from "@langchain/langgraph";
+import { ToolNode } from "@langchain/langgraph/prebuilt";
+import { z } from "zod";
+
+export class ScriptedModel extends BaseChatModel {
+  calls = 0;
+
+  constructor(fields: BaseChatModelParams = {}) {
+    super(fields);
+  }
+
+  _llmType(): string {
+    return "scripted";
+  }
+
+  override bindTools(): this {
+    return this;
+  }
+
+  async _generate(messages: BaseMessage[]): Promise<ChatResult> {
+    this.calls += 1;
+    const answered = messages.some((m) => m.getType() === "tool");
+    const message = answered
+      ? new AIMessage({
+          content: "It is sunny in Paris.",
+          usage_metadata: { input_tokens: 30, output_tokens: 7, total_tokens: 37 },
+          response_metadata: { finish_reason: "stop" },
+        })
+      : new AIMessage({
+          content: "",
+          tool_calls: [{ id: "call_1", name: "get_weather", args: { city: "Paris" }, type: "tool_call" }],
+          usage_metadata: { input_tokens: 12, output_tokens: 5, total_tokens: 17 },
+          response_metadata: { finish_reason: "tool_calls" },
+        });
+    return { generations: [{ text: typeof message.content === "string" ? message.content : "", message }] };
+  }
+}
+
+const getWeather = tool(async ({ city }: { city: string }) => `sunny in ${city}`, {
+  name: "get_weather",
+  description: "Current weather for a city",
+  schema: z.object({ city: z.string() }),
+});
+
+export function buildGraph(model: ScriptedModel) {
+  const callModel = async (state: typeof MessagesAnnotation.State) => ({
+    messages: [await model.invoke(state.messages)],
+  });
+  const route = (state: typeof MessagesAnnotation.State) => {
+    const last = state.messages[state.messages.length - 1] as AIMessage;
+    return last.tool_calls?.length ? "tools" : END;
+  };
+  return new StateGraph(MessagesAnnotation)
+    .addNode("agent", callModel)
+    .addNode("tools", new ToolNode([getWeather]))
+    .addEdge(START, "agent")
+    .addConditionalEdges("agent", route, ["tools", END])
+    .addEdge("tools", "agent")
+    .compile({ name: "weather_graph" });
+}
+
+export const question = () => ({ messages: [new HumanMessage("weather?")] });

package/.next/standalone/sdk/typescript/integration/fixtures/nextjs/lib/llamaindex.ts

@@ -0,0 +1,98 @@
+// The llamaindex-0.12 fixture's scripted LLM and tool, so a route's trace can
+// be compared with that fixture's `workflow` trace under plain Node.
+//
+// One difference, in spelling only: the fixture decorates `chat` with
+// `@wrapEventCaller @wrapLLMEvent`, and Next's compiler does not take standard
+// decorators. They are applied here by hand — the same two functions, in the
+// same order, with the context object a decorator receives.
+import { wrapEventCaller, wrapLLMEvent } from "@llamaindex/core/decorator";
+import {
+  ToolCallLLM,
+  type ChatMessage,
+  type ChatResponse,
+  type ChatResponseChunk,
+  type LLMChatParamsNonStreaming,
+  type LLMChatParamsStreaming,
+  type LLMMetadata,
+  type ToolCallLLMMessageOptions,
+} from "@llamaindex/core/llms";
+import { tool } from "llamaindex";
+import { z } from "zod";
+
+type Options = ToolCallLLMMessageOptions;
+
+interface Turn {
+  tool?: { name: string; input: Record<string, unknown>; id: string };
+  text?: string;
+  usage: { prompt_tokens: number; completion_tokens: number };
+}
+
+const weatherTurns = (): Turn[] => [
+  { tool: { name: "get_weather", input: { city: "Paris" }, id: "call_1" }, usage: { prompt_tokens: 12, completion_tokens: 5 } },
+  { text: "It is sunny in Paris.", usage: { prompt_tokens: 30, completion_tokens: 7 } },
+];
+
+const initializers: Array<(this: unknown) => void> = [];
+
+export class ScriptedLLM extends ToolCallLLM {
+  supportToolCall = true;
+  metadata: LLMMetadata = {
+    model: "scripted-1",
+    temperature: 0,
+    topP: 1,
+    contextWindow: 4096,
+    tokenizer: undefined,
+    structuredOutput: false,
+  };
+  private readonly turns: Turn[];
+
+  constructor(turns: Turn[] = weatherTurns()) {
+    super();
+    this.turns = turns;
+    for (const init of initializers) init.call(this);
+  }
+
+  chat(params: LLMChatParamsStreaming<object, Options>): Promise<AsyncIterable<ChatResponseChunk<Options>>>;
+  chat(params: LLMChatParamsNonStreaming<object, Options>): Promise<ChatResponse<Options>>;
+  async chat(
+    params: LLMChatParamsStreaming<object, Options> | LLMChatParamsNonStreaming<object, Options>,
+  ): Promise<AsyncIterable<ChatResponseChunk<Options>> | ChatResponse<Options>> {
+    const turn = this.turns.shift() ?? { text: "done", usage: { prompt_tokens: 1, completion_tokens: 1 } };
+    const options: Options = turn.tool ? { toolCall: [turn.tool] } : {};
+    const message: ChatMessage<Options> = { role: "assistant", content: turn.text ?? "", options };
+    if (params.stream) {
+      return (async function* (): AsyncGenerator<ChatResponseChunk<Options>> {
+        yield { delta: turn.text ?? "", raw: { choices: [{ delta: {} }] }, options };
+        yield { delta: "", raw: { choices: [], usage: turn.usage }, options: {} };
+      })();
+    }
+    return { message, raw: { choices: [{ finish_reason: turn.tool ? "tool_calls" : "stop" }], usage: turn.usage } };
+  }
+}
+
+{
+  const context = {
+    kind: "method",
+    name: "chat",
+    static: false,
+    private: false,
+    access: { has: () => true, get: () => undefined },
+    metadata: {},
+    addInitializer: (init: (this: unknown) => void) => void initializers.push(init),
+  } as never;
+  const proto = ScriptedLLM.prototype as unknown as { chat: (...args: unknown[]) => unknown };
+  // `@wrapEventCaller @wrapLLMEvent` applies bottom-up: wrapLLMEvent first.
+  proto.chat = (wrapEventCaller as (m: unknown, c: never) => typeof proto.chat)(
+    (wrapLLMEvent as (m: unknown, c: never) => typeof proto.chat)(proto.chat, context),
+    context,
+  );
+}
+
+export const getWeather = tool({
+  name: "get_weather",
+  description: "Current weather for a city",
+  parameters: z.object({ city: z.string() }),
+  execute: ({ city }) => `sunny in ${city}`,
+});
+
+export const QUESTION = "weather in Paris?";

package/.next/standalone/sdk/typescript/integration/fixtures/nextjs/lib/mastra.ts

@@ -0,0 +1,90 @@
+// The mastra-1 fixture's scripted model, tool and agent, verbatim (minus the
+// gate/failure options no route uses), so a route's trace can be compared with
+// that fixture's trace under plain Node.
+import { Agent } from "@mastra/core/agent";
+import { createTool } from "@mastra/core/tools";
+import { z } from "zod";
+
+type Turn = { tool: string; input: Record<string, unknown>; usage: [number, number] } | { text: string; usage: [number, number] };
+
+function scriptedModel(turns: Turn[]) {
+  let calls = 0;
+  const next = (): Turn => turns[calls++ % turns.length]!;
+  const usage = ([input, output]: [number, number]) => ({
+    inputTokens: input,
+    outputTokens: output,
+    totalTokens: input + output,
+  });
+  return {
+    specificationVersion: "v2" as const,
+    provider: "scripted",
+    modelId: "scripted-model",
+    supportedUrls: {},
+    async doGenerate() {
+      const turn = next();
+      return "tool" in turn
+        ? {
+            content: [{ type: "tool-call" as const, toolCallId: `call_${calls}`, toolName: turn.tool, input: JSON.stringify(turn.input) }],
+            finishReason: "tool-calls" as const,
+            usage: usage(turn.usage),
+            warnings: [],
+          }
+        : {
+            content: [{ type: "text" as const, text: turn.text }],
+            finishReason: "stop" as const,
+            usage: usage(turn.usage),
+            warnings: [],
+          };
+    },
+    async doStream() {
+      const turn = next();
+      const parts: unknown[] = [
+        { type: "stream-start", warnings: [] },
+        { type: "response-metadata", id: `resp_${calls}`, modelId: "scripted-model", timestamp: new Date(0) },
+      ];
+      if ("tool" in turn) {
+        parts.push({ type: "tool-call", toolCallId: `call_${calls}`, toolName: turn.tool, input: JSON.stringify(turn.input) });
+        parts.push({ type: "finish", finishReason: "tool-calls", usage: usage(turn.usage) });
+      } else {
+        parts.push({ type: "text-start", id: "t" });
+        const cut = turn.text.indexOf(" ", turn.text.length / 2) + 1;
+        for (const delta of [turn.text.slice(0, cut), turn.text.slice(cut)]) {
+          parts.push({ type: "text-delta", id: "t", delta });
+        }
+        parts.push({ type: "text-end", id: "t" });
+        parts.push({ type: "finish", finishReason: "stop", usage: usage(turn.usage) });
+      }
+      return {
+        stream: new ReadableStream({
+          start(controller) {
+            for (const part of parts) controller.enqueue(part);
+            controller.close();
+          },
+        }),
+      };
+    },
+  };
+}
+
+const WEATHER_TURNS: Turn[] = [
+  { tool: "weather", input: { city: "Paris" }, usage: [11, 7] },
+  { text: "It is sunny in Paris.", usage: [23, 9] },
+];
+
+export const weather = createTool({
+  id: "weather",
+  description: "Current weather for a city",
+  inputSchema: z.object({ city: z.string() }),
+  execute: async (input: { city: string }) => ({ city: input.city, forecast: "sunny" }),
+});
+
+export const weatherAgent = () =>
+  new Agent({
+    id: "weather-agent",
+    name: "weather-agent",
+    instructions: "Answer weather questions.",
+    model: scriptedModel(WEATHER_TURNS) as never,
+    tools: { weather },
+  });
+
+export const question = "What is the weather in Paris?";

package/.next/standalone/sdk/typescript/integration/fixtures/nextjs/next.config.ts

@@ -0,0 +1,52 @@
+import { dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+
+import { withFailproofai } from "@failproofai/sdk/next";
+import type { NextConfig } from "next";
+
+const root = dirname(fileURLToPath(import.meta.url));
+
+/**
+ * One app, built several ways by `nextjs.test.ts`, each into its own distDir:
+ *
+ *   FAILPROOFAI_IT_NEXT_EXTERNAL=1  the frameworks (and the SDK) are listed in
+ *                                   `serverExternalPackages`, so the server
+ *                                   loads them from node_modules at run time
+ *                                   (with `import()`, under both bundlers). Unset: Next's DEFAULT, which bundles
+ *                                   all four — none of them is on Next's
+ *                                   built-in external list.
+ *
+ * Every build includes `app/api/edge/route.ts`, an Edge-runtime route that
+ * imports the SDK: an SDK whose import broke the Edge runtime fails the build.
+ */
+const external = process.env.FAILPROOFAI_IT_NEXT_EXTERNAL === "1";
+/**
+ * FAILPROOFAI_IT_NEXT_WRAP=1  the documented setup: the app lists nothing
+ *                             itself and exports `withFailproofai(config)`.
+ */
+const wrap = process.env.FAILPROOFAI_IT_NEXT_WRAP === "1";
+
+const config: NextConfig = {
+  distDir: process.env.FAILPROOFAI_IT_NEXT_DIST ?? ".next",
+  serverExternalPackages: external
+    ? [
+        "@failproofai/sdk",
+        "@langchain/core",
+        "@langchain/langgraph",
+        "ai",
+        "@mastra/core",
+        "llamaindex",
+        "@llamaindex/core",
+        "@llamaindex/workflow",
+      ]
+    : [],
+  // The build is about what runs, not about the fixtures' types (which the
+  // framework fixtures typecheck on their own).
+  typescript: { ignoreBuildErrors: true },
+  // This fixture sits inside a repo with other lockfiles; without these, Next
+  // guesses the workspace root from them and traces files from the wrong one.
+  outputFileTracingRoot: root,
+  turbopack: { root },
+};
+
+export default wrap ? withFailproofai(config) : config;