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

package/.next/standalone/sdk/typescript/integration/fixtures/ai-4/agent.ts

@@ -0,0 +1,337 @@
+// Vercel AI SDK 4.x consumer. Run as `node agent.{mjs,cjs} <case>`.
+//
+// Deliberately the shape a customer writes: import `ai`, pass the adapter at
+// the call site (or wrap the model, or instrument), run. The scripted mock
+// model makes it deterministic and offline — the tool loop's first call asks
+// for `weather`, the next one answers — and never touches a real provider.
+//
+// Everything below the `--- the same in every fixture` line is the same
+// program in every ai-* fixture; only the model mock and the tool/loop
+// spelling above it change between majors.
+import { createRequire } from "node:module";
+import { join } from "node:path";
+
+import * as failproofai from "@failproofai/sdk";
+import { middleware, telemetry, tracer, wrapModel } from "@failproofai/sdk/ai";
+import {
+  generateObject,
+  generateText,
+  simulateReadableStream,
+  streamObject,
+  streamText,
+  tool,
+  wrapLanguageModel,
+} from "ai";
+import { MockLanguageModelV1 } from "ai/test";
+import { z } from "zod";
+
+// --- version-specific: LanguageModelV1 (promptTokens/completionTokens, `text` + `toolCalls`)
+
+type Script = "loop" | "answer" | "object" | "fail";
+type StreamPart = Awaited<ReturnType<MockLanguageModelV1["doStream"]>>["stream"] extends ReadableStream<infer P> ? P : never;
+
+const usage = (input: number, output: number) => ({ promptTokens: input, completionTokens: output });
+const rawCall = { rawPrompt: null, rawSettings: {} };
+
+function scripted(script: Script = "loop") {
+  let generated = 0;
+  let streamed = 0;
+  return new MockLanguageModelV1({
+    provider: "mock-provider",
+    modelId: "mock-model",
+    // v4 asks the model how to produce an object; v5+ always use JSON mode.
+    defaultObjectGenerationMode: "json",
+    doGenerate: async () => {
+      generated += 1;
+      if (script === "fail") throw new Error("model exploded");
+      if (script === "object") return { text: '{"city":"Paris"}', finishReason: "stop", usage: usage(5, 3), rawCall };
+      if (script === "loop" && generated === 1) {
+        return {
+          toolCalls: [{ toolCallType: "function", toolCallId: "call-1", toolName: "weather", args: '{"city":"Paris"}' }],
+          finishReason: "tool-calls",
+          usage: usage(11, 7),
+          rawCall,
+        };
+      }
+      return { text: "It is 20C in Paris.", finishReason: "stop", usage: usage(23, 9), rawCall };
+    },
+    doStream: async () => {
+      streamed += 1;
+      if (script === "fail") throw new Error("model exploded");
+      const text = (...deltas: string[]): StreamPart[] => deltas.map((textDelta): StreamPart => ({ type: "text-delta", textDelta }));
+      const chunks: StreamPart[] =
+        script === "object"
+          ? [...text('{"city":', '"Paris"}'), { type: "finish", finishReason: "stop", usage: usage(5, 3) }]
+          : script === "loop" && streamed === 1
+            ? [
+                { type: "tool-call", toolCallType: "function", toolCallId: "call-s1", toolName: "weather", args: '{"city":"Rome"}' },
+                { type: "finish", finishReason: "tool-calls", usage: usage(13, 4) },
+              ]
+            : [...text("Rome is ", "25C."), { type: "finish", finishReason: "stop", usage: usage(30, 6) }];
+      return { stream: simulateReadableStream({ chunks }), rawCall };
+    },
+  });
+}
+
+const makeTools = (fail = false) => ({
+  weather: tool({
+    description: "Current weather for a city",
+    parameters: z.object({ city: z.string() }),
+    execute: async ({ city }: { city: string }) => {
+      if (fail) throw new Error("weather service down");
+      return { city, celsius: city === "Paris" ? 20 : 25 };
+    },
+  }),
+});
+const loop = { maxSteps: 4 };
+
+/** The bare tracer, as `experimental_telemetry.tracer` (v4–v6 only: v7 has no such option). */
+async function viaTracer(prompt: string): Promise<string> {
+  const { text } = await generateText({
+    model: scripted("answer"),
+    prompt,
+    experimental_telemetry: { isEnabled: true, tracer: tracer() },
+  });
+  return text;
+}
+
+// --- the same in every fixture
+
+type Telemetry = ReturnType<typeof telemetry> | { isEnabled: true; functionId: string };
+
+async function ask(model: Parameters<typeof generateText>[0]["model"], options: { telemetry?: Telemetry; tools?: boolean; failTool?: boolean } = {}) {
+  const result = await generateText({
+    model,
+    prompt: "Weather in Paris?",
+    ...(options.tools === false ? {} : { tools: makeTools(options.failTool), ...loop }),
+    ...(options.telemetry ? { experimental_telemetry: options.telemetry } : {}),
+  });
+  return result.text;
+}
+
+async function askStreaming(model: Parameters<typeof streamText>[0]["model"], options: { telemetry?: Telemetry; tools?: boolean } = {}) {
+  const result = streamText({
+    model,
+    prompt: "Weather in Rome?",
+    ...(options.tools === false ? {} : { tools: makeTools(), ...loop }),
+    ...(options.telemetry ? { experimental_telemetry: options.telemetry } : {}),
+  });
+  let text = "";
+  for await (const delta of result.textStream) text += delta;
+  return text;
+}
+
+const schema = z.object({ city: z.string() });
+const report = (value: unknown) => console.log(JSON.stringify(value));
+
+/** The README's call sites, verbatim apart from the mock standing in for a provider. */
+async function readme(): Promise<void> {
+  const model = scripted("answer");
+  const prompt = "Weather in Paris?";
+  const { text } = await generateText({
+    model,
+    prompt,
+    experimental_telemetry: telemetry({ functionId: "answer-question" }),
+  });
+  const wrapped = await wrapModel(scripted("answer"));
+  const viaMiddleware = wrapLanguageModel({ model: scripted("answer"), middleware: middleware() });
+  const withMetadata = await generateText({
+    model: scripted("answer"),
+    prompt,
+    experimental_telemetry: telemetry({ functionId: "tagged", metadata: { tenant: "acme", attempt: 1 } }),
+  });
+  report({ text, wrapped: (await generateText({ model: wrapped, prompt })).text, viaMiddleware: viaMiddleware.modelId, withMetadata: withMetadata.text, withTracer: await viaTracer(prompt) });
+}
+
+/**
+ * The customer's own OpenTelemetry, set up AFTER `instrument("ai")` — the
+ * usual order when tracing starts in a module loaded later (a `NodeSDK`
+ * started from an instrumentation file). Null when `@opentelemetry/api` is not
+ * installed (ai 7 dropped the dependency).
+ */
+function customerTracing(): { registered: boolean; ended: () => string[] } | null {
+  interface Api {
+    trace: {
+      setGlobalTracerProvider(provider: unknown): boolean;
+      getTracer(name: string): { startSpan(name: string): { end(): void } };
+    };
+  }
+  let api: Api;
+  try {
+    api = createRequire(join(process.cwd(), "agent.js"))("@opentelemetry/api") as Api;
+  } catch {
+    return null;
+  }
+  const ended: string[] = [];
+  const span = (name: string) => ({
+    setAttribute() { return this; },
+    setAttributes() { return this; },
+    addEvent() { return this; },
+    addLink() { return this; },
+    addLinks() { return this; },
+    setStatus() { return this; },
+    updateName() { return this; },
+    recordException() {},
+    isRecording: () => true,
+    spanContext: () => ({ traceId: "0".repeat(31) + "1", spanId: "0".repeat(15) + "1", traceFlags: 1 }),
+    end: () => void ended.push(name),
+  });
+  const theirs = {
+    startSpan: (name: string) => span(name),
+    startActiveSpan: (name: string, ...rest: unknown[]) => (rest[rest.length - 1] as (s: unknown) => unknown)(span(name)),
+  };
+  const registered = api.trace.setGlobalTracerProvider({ getTracer: () => theirs });
+  // What an http / pg / Next.js instrumentation does with the global API.
+  api.trace.getTracer("my-service").startSpan("http.request").end();
+  return { registered, ended: () => [...new Set(ended)].sort() };
+}
+
+/** A model whose stream breaks part-way: the provider connection dropped. */
+function breakMidStream<M>(model: M): M {
+  const target = model as unknown as { doStream: (options: unknown) => PromiseLike<{ stream: ReadableStream<unknown> }> };
+  const original = target.doStream.bind(target);
+  target.doStream = async (options: unknown) => {
+    const result = await original(options);
+    const reader = result.stream.getReader();
+    let parts = 0;
+    return {
+      ...result,
+      stream: new ReadableStream<unknown>({
+        async pull(controller) {
+          if (parts++ === 2) {
+            controller.error(new Error("connection reset"));
+            return;
+          }
+          const next = await reader.read();
+          if (next.done) controller.close();
+          else controller.enqueue(next.value);
+        },
+      }),
+    };
+  };
+  return model;
+}
+
+/** Call a model's `doStream` directly, as a provider-level consumer does. */
+async function openStream(model: unknown): Promise<ReadableStreamDefaultReader<unknown>> {
+  const call = {
+    inputFormat: "prompt",
+    mode: { type: "regular" },
+    prompt: [{ role: "user", content: [{ type: "text", text: "Weather in Rome?" }] }],
+  };
+  const { stream } = await (model as { doStream(options: unknown): PromiseLike<{ stream: ReadableStream<unknown> }> }).doStream(call);
+  return stream.getReader();
+}
+
+async function main(scenario: string): Promise<void> {
+  switch (scenario) {
+    case "generate":
+      report({ text: await ask(scripted(), { telemetry: telemetry({ functionId: "weather-agent" }) }) });
+      break;
+    case "stream":
+      report({ text: await askStreaming(scripted(), { telemetry: telemetry({ functionId: "weather-agent" }) }) });
+      break;
+    case "object": {
+      const { object } = await generateObject({ model: scripted("object"), schema, prompt: "Where?", experimental_telemetry: telemetry({ functionId: "extractor" }) });
+      report({ object });
+      break;
+    }
+    case "stream-object": {
+      const result = streamObject({ model: scripted("object"), schema, prompt: "Where?", experimental_telemetry: telemetry({ functionId: "extractor" }) });
+      for await (const _ of result.partialObjectStream) void _;
+      report({ object: await result.object });
+      break;
+    }
+    case "wrap":
+      report({ text: await ask(await wrapModel(scripted("answer")), { tools: false }) });
+      break;
+    case "wrap-stream":
+      report({ text: await askStreaming(await wrapModel(scripted("answer")), { tools: false }) });
+      break;
+    case "wrap-in-agent":
+      await failproofai.session({ sessionId: "req-1" }, () =>
+        failproofai.agent("planner", { goal: "plan" }, async () => report({ text: await ask(await wrapModel(scripted())) })),
+      );
+      break;
+    case "wrap-and-telemetry":
+      report({ text: await ask(await wrapModel(scripted()), { telemetry: telemetry({ functionId: "weather-agent" }) }) });
+      break;
+    case "instrument":
+      report({ instrumented: await failproofai.instrument("ai") });
+      report({ text: await ask(scripted(), { telemetry: { isEnabled: true, functionId: "weather-agent" } }) });
+      break;
+    case "instrument-stream":
+      report({ instrumented: await failproofai.instrument("ai") });
+      report({ text: await askStreaming(scripted(), { telemetry: { isEnabled: true, functionId: "weather-agent" } }) });
+      break;
+    case "instrument-global":
+      report({ instrumented: await failproofai.instrument("ai", { registerGlobalTracer: true }) });
+      report({ text: await ask(scripted(), { telemetry: { isEnabled: true, functionId: "weather-agent" } }) });
+      break;
+    case "instrument-global-stream":
+      report({ instrumented: await failproofai.instrument("ai", { registerGlobalTracer: true }) });
+      report({ text: await askStreaming(scripted(), { telemetry: { isEnabled: true, functionId: "weather-agent" } }) });
+      break;
+    case "instrument-then-otel": {
+      report({ instrumented: await failproofai.instrument("ai") });
+      const customer = customerTracing();
+      const text = await ask(scripted(), { telemetry: { isEnabled: true, functionId: "weather-agent" } });
+      report({ text, customer: customer === null ? "absent" : { registered: customer.registered, ended: customer.ended() } });
+      break;
+    }
+    case "wrap-stream-cancel": {
+      const reader = await openStream(await wrapModel(scripted("answer")));
+      await reader.read();
+      await reader.cancel("client disconnected");
+      report({ cancelled: true });
+      break;
+    }
+    case "wrap-stream-error": {
+      const reader = await openStream(await wrapModel(breakMidStream(scripted("answer"))));
+      try {
+        while (!(await reader.read()).done) {
+          // drain
+        }
+        report({ drained: true });
+      } catch (error) {
+        report({ threw: (error as Error).message });
+      }
+      break;
+    }
+    case "uninstrument":
+      report({ instrumented: await failproofai.instrument("ai") });
+      report({ removed: failproofai.uninstrument() });
+      report({ text: await ask(scripted(), { telemetry: { isEnabled: true, functionId: "weather-agent" } }) });
+      break;
+    case "tool-error":
+      try {
+        report({ text: await ask(scripted(), { telemetry: telemetry({ functionId: "weather-agent" }), failTool: true }) });
+      } catch (error) {
+        report({ threw: (error as Error).message });
+      }
+      break;
+    case "model-error":
+      try {
+        report({ text: await ask(scripted("fail"), { telemetry: telemetry({ functionId: "weather-agent" }), tools: false }) });
+      } catch (error) {
+        report({ threw: (error as Error).message });
+      }
+      break;
+    case "scope":
+      await failproofai.session({ sessionId: "req-1" }, () =>
+        failproofai.agent("planner", { goal: "plan" }, () => ask(scripted(), { telemetry: telemetry({ functionId: "weather-agent" }) })),
+      );
+      break;
+    case "readme":
+      await readme();
+      break;
+    default:
+      throw new Error(`unknown scenario ${scenario}`);
+  }
+  await failproofai.flush();
+}
+
+main(process.argv[2] ?? "generate").catch((error: unknown) => {
+  console.error("FATAL", error);
+  process.exit(1);
+});

package/.next/standalone/sdk/typescript/integration/fixtures/ai-4/package-lock.json

@@ -0,0 +1,281 @@
+{
+  "name": "failproofai-it-ai-4",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "failproofai-it-ai-4",
+      "dependencies": {
+        "ai": "4.3.19",
+        "zod": "3.25.76"
+      },
+      "devDependencies": {
+        "@types/node": "22.20.4"
+      }
+    },
+    "node_modules/@ai-sdk/provider": {
+      "version": "1.1.3",
+      "resolved": "https://registry.npmjs.org/@ai-sdk/provider/-/provider-1.1.3.tgz",
+      "integrity": "sha512-qZMxYJ0qqX/RfnuIaab+zp8UAeJn/ygXXAffR5I4N0n1IrvA6qBsjc8hXLmBiMV2zoXlifkacF7sEFnYnjBcqg==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "json-schema": "^0.4.0"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@ai-sdk/provider-utils": {
+      "version": "2.2.8",
+      "resolved": "https://registry.npmjs.org/@ai-sdk/provider-utils/-/provider-utils-2.2.8.tgz",
+      "integrity": "sha512-fqhG+4sCVv8x7nFzYnFo19ryhAa3w096Kmc3hWxMQfW/TubPOmt3A6tYZhl4mUfQWWQMsuSkLrtjlWuXBVSGQA==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@ai-sdk/provider": "1.1.3",
+        "nanoid": "^3.3.8",
+        "secure-json-parse": "^2.7.0"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "peerDependencies": {
+        "zod": "^3.23.8"
+      }
+    },
+    "node_modules/@ai-sdk/react": {
+      "version": "1.2.12",
+      "resolved": "https://registry.npmjs.org/@ai-sdk/react/-/react-1.2.12.tgz",
+      "integrity": "sha512-jK1IZZ22evPZoQW3vlkZ7wvjYGYF+tRBKXtrcolduIkQ/m/sOAVcVeVDUDvh1T91xCnWCdUGCPZg2avZ90mv3g==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@ai-sdk/provider-utils": "2.2.8",
+        "@ai-sdk/ui-utils": "1.2.11",
+        "swr": "^2.2.5",
+        "throttleit": "2.1.0"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "peerDependencies": {
+        "react": "^18 || ^19 || ^19.0.0-rc",
+        "zod": "^3.23.8"
+      },
+      "peerDependenciesMeta": {
+        "zod": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@ai-sdk/ui-utils": {
+      "version": "1.2.11",
+      "resolved": "https://registry.npmjs.org/@ai-sdk/ui-utils/-/ui-utils-1.2.11.tgz",
+      "integrity": "sha512-3zcwCc8ezzFlwp3ZD15wAPjf2Au4s3vAbKsXQVyhxODHcmu0iyPO2Eua6D/vicq/AUm/BAo60r97O6HU+EI0+w==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@ai-sdk/provider": "1.1.3",
+        "@ai-sdk/provider-utils": "2.2.8",
+        "zod-to-json-schema": "^3.24.1"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "peerDependencies": {
+        "zod": "^3.23.8"
+      }
+    },
+    "node_modules/@opentelemetry/api": {
+      "version": "1.9.0",
+      "resolved": "https://registry.npmjs.org/@opentelemetry/api/-/api-1.9.0.tgz",
+      "integrity": "sha512-3giAOQvZiH5F9bMlMiv8+GSPMeqg0dbaeo58/0SlA9sxSqZhnUtxzX9/2FzyhS9sWQf5S0GJE0AKBrFqjpeYcg==",
+      "license": "Apache-2.0",
+      "engines": {
+        "node": ">=8.0.0"
+      }
+    },
+    "node_modules/@types/diff-match-patch": {
+      "version": "1.0.36",
+      "resolved": "https://registry.npmjs.org/@types/diff-match-patch/-/diff-match-patch-1.0.36.tgz",
+      "integrity": "sha512-xFdR6tkm0MWvBfO8xXCSsinYxHcqkQUlcHeSpMC2ukzOb6lwQAfDmW+Qt0AvlGd8HpsS28qKsB+oPeJn9I39jg==",
+      "license": "MIT"
+    },
+    "node_modules/@types/node": {
+      "version": "22.20.4",
+      "resolved": "https://registry.npmjs.org/@types/node/-/node-22.20.4.tgz",
+      "integrity": "sha512-zJRE40jpHtKqE/C4fgHrAKQLJuSpzEnP9ff9Y7YtoR3Wd2pwqzlekDeEuUQXjRd+QCYnVnNwuJYmhdk9XV8gvA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "undici-types": "~6.21.0"
+      }
+    },
+    "node_modules/ai": {
+      "version": "4.3.19",
+      "resolved": "https://registry.npmjs.org/ai/-/ai-4.3.19.tgz",
+      "integrity": "sha512-dIE2bfNpqHN3r6IINp9znguYdhIOheKW2LDigAMrgt/upT3B8eBGPSCblENvaZGoq+hxaN9fSMzjWpbqloP+7Q==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@ai-sdk/provider": "1.1.3",
+        "@ai-sdk/provider-utils": "2.2.8",
+        "@ai-sdk/react": "1.2.12",
+        "@ai-sdk/ui-utils": "1.2.11",
+        "@opentelemetry/api": "1.9.0",
+        "jsondiffpatch": "0.6.0"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "peerDependencies": {
+        "react": "^18 || ^19 || ^19.0.0-rc",
+        "zod": "^3.23.8"
+      },
+      "peerDependenciesMeta": {
+        "react": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/chalk": {
+      "version": "5.6.2",
+      "resolved": "https://registry.npmjs.org/chalk/-/chalk-5.6.2.tgz",
+      "integrity": "sha512-7NzBL0rN6fMUW+f7A6Io4h40qQlG+xGmtMxfbnH/K7TAtt8JQWVQK+6g0UXKMeVJoyV5EkkNsErQ8pVD3bLHbA==",
+      "license": "MIT",
+      "engines": {
+        "node": "^12.17.0 || ^14.13 || >=16.0.0"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/chalk?sponsor=1"
+      }
+    },
+    "node_modules/dequal": {
+      "version": "2.0.3",
+      "resolved": "https://registry.npmjs.org/dequal/-/dequal-2.0.3.tgz",
+      "integrity": "sha512-0je+qPKHEMohvfRTCEo3CrPG6cAzAYgmzKyxRiYSSDkS6eGJdyVJm7WaYA5ECaAD9wLB2T4EEeymA5aFVcYXCA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/diff-match-patch": {
+      "version": "1.0.5",
+      "resolved": "https://registry.npmjs.org/diff-match-patch/-/diff-match-patch-1.0.5.tgz",
+      "integrity": "sha512-IayShXAgj/QMXgB0IWmKx+rOPuGMhqm5w6jvFxmVenXKIzRqTAAsbBPT3kWQeGANj3jGgvcvv4yK6SxqYmikgw==",
+      "license": "Apache-2.0"
+    },
+    "node_modules/json-schema": {
+      "version": "0.4.0",
+      "resolved": "https://registry.npmjs.org/json-schema/-/json-schema-0.4.0.tgz",
+      "integrity": "sha512-es94M3nTIfsEPisRafak+HDLfHXnKBhV3vU5eqPcS3flIWqcxJWgXHXiey3YrpaNsanY5ei1VoYEbOzijuq9BA==",
+      "license": "(AFL-2.1 OR BSD-3-Clause)"
+    },
+    "node_modules/jsondiffpatch": {
+      "version": "0.6.0",
+      "resolved": "https://registry.npmjs.org/jsondiffpatch/-/jsondiffpatch-0.6.0.tgz",
+      "integrity": "sha512-3QItJOXp2AP1uv7waBkao5nCvhEv+QmJAd38Ybq7wNI74Q+BBmnLn4EDKz6yI9xGAIQoUF87qHt+kc1IVxB4zQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/diff-match-patch": "^1.0.36",
+        "chalk": "^5.3.0",
+        "diff-match-patch": "^1.0.5"
+      },
+      "bin": {
+        "jsondiffpatch": "bin/jsondiffpatch.js"
+      },
+      "engines": {
+        "node": "^18.0.0 || >=20.0.0"
+      }
+    },
+    "node_modules/nanoid": {
+      "version": "3.3.19",
+      "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.19.tgz",
+      "integrity": "sha512-Y2tUNy4ouw6tq5oDSKeQYGOyhkUBhNOcGV/02KC+6kd9eDGqdZd++mjMiIDilrBYvjEnCYvVtsuHCuP+okSfug==",
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "license": "MIT",
+      "bin": {
+        "nanoid": "bin/nanoid.cjs"
+      },
+      "engines": {
+        "node": "^10 || ^12 || ^13.7 || ^14 || >=15.0.1"
+      }
+    },
+    "node_modules/react": {
+      "version": "19.3.0",
+      "resolved": "https://registry.npmjs.org/react/-/react-19.3.0.tgz",
+      "integrity": "sha512-E8LUcbtBWt20bbl2YoHfx4ZDBdxVTfOKtCZn9cDSJ4l6/nuoApcpIBcj47t2wZoVX8g2ZHuMHbiShgCR1T5Sog==",
+      "license": "MIT",
+      "peer": true,
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/secure-json-parse": {
+      "version": "2.7.0",
+      "resolved": "https://registry.npmjs.org/secure-json-parse/-/secure-json-parse-2.7.0.tgz",
+      "integrity": "sha512-6aU+Rwsezw7VR8/nyvKTx8QpWH9FrcYiXXlqC4z5d5XQBDRqtbfsRjnwGyqbi3gddNtWHuEk9OANUotL26qKUw==",
+      "license": "BSD-3-Clause"
+    },
+    "node_modules/swr": {
+      "version": "2.5.1",
+      "resolved": "https://registry.npmjs.org/swr/-/swr-2.5.1.tgz",
+      "integrity": "sha512-BRw55e8r0B7SpDN20CAzoQAHl7y1yP7/Zt7oqUjMv0vSt2u2Xnkm88Ws+VypbV9BXHQVuSuyVq7zMjO16wSExw==",
+      "license": "MIT",
+      "dependencies": {
+        "dequal": "^2.0.3",
+        "use-sync-external-store": "^1.6.0"
+      },
+      "peerDependencies": {
+        "react": "^16.11.0 || ^17.0.0 || ^18.0.0 || ^19.0.0"
+      }
+    },
+    "node_modules/throttleit": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/throttleit/-/throttleit-2.1.0.tgz",
+      "integrity": "sha512-nt6AMGKW1p/70DF/hGBdJB57B8Tspmbp5gfJ8ilhLnt7kkr2ye7hzD6NVG8GGErk2HWF34igrL2CXmNIkzKqKw==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/undici-types": {
+      "version": "6.21.0",
+      "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-6.21.0.tgz",
+      "integrity": "sha512-iwDZqg0QAGrg9Rav5H4n0M64c3mkR59cJ6wQp+7C4nI0gsmExaedaYLNO44eT4AtBBwjbTiGPMlt2Md0T9H9JQ==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/use-sync-external-store": {
+      "version": "1.7.0",
+      "resolved": "https://registry.npmjs.org/use-sync-external-store/-/use-sync-external-store-1.7.0.tgz",
+      "integrity": "sha512-6L+EeigHMQhdaIPNIFUKwfWJSwWFQ8gJbJ2DLOs5sDIegTwR9fRxvnM3uciHKjIZhFz+KAv2emhWMRvDmMcY8A==",
+      "license": "MIT",
+      "peerDependencies": {
+        "react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0"
+      }
+    },
+    "node_modules/zod": {
+      "version": "3.25.76",
+      "resolved": "https://registry.npmjs.org/zod/-/zod-3.25.76.tgz",
+      "integrity": "sha512-gzUt/qt81nXsFGKIFcC3YnfEAx5NkunCfnDlvuBSSFS02bcXu4Lmea0AFIUwbLWxWPx3d9p8S5QoaujKcNQxcQ==",
+      "license": "MIT",
+      "funding": {
+        "url": "https://github.com/sponsors/colinhacks"
+      }
+    },
+    "node_modules/zod-to-json-schema": {
+      "version": "3.25.2",
+      "resolved": "https://registry.npmjs.org/zod-to-json-schema/-/zod-to-json-schema-3.25.2.tgz",
+      "integrity": "sha512-O/PgfnpT1xKSDeQYSCfRI5Gy3hPf91mKVDuYLUHZJMiDFptvP41MSnWofm8dnCm0256ZNfZIM7DSzuSMAFnjHA==",
+      "license": "ISC",
+      "peerDependencies": {
+        "zod": "^3.25.28 || ^4"
+      }
+    }
+  }
+}

package/.next/standalone/sdk/typescript/integration/fixtures/ai-4/package.json

@@ -0,0 +1,13 @@
+{
+  "name": "failproofai-it-ai-4",
+  "private": true,
+  "type": "module",
+  "description": "Integration fixture: Vercel AI SDK 4.x against the packed @failproofai/sdk.",
+  "dependencies": {
+    "ai": "4.3.19",
+    "zod": "3.25.76"
+  },
+  "devDependencies": {
+    "@types/node": "22.20.4"
+  }
+}