failproofai 1.0.7-beta.1 → 1.0.7

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

@@ -0,0 +1,342 @@
+// Vercel AI SDK 5.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,
+  stepCountIs,
+  streamObject,
+  streamText,
+  tool,
+  wrapLanguageModel,
+} from "ai";
+import { MockLanguageModelV2 } from "ai/test";
+import { z } from "zod";
+
+// --- version-specific: LanguageModelV2 (flat usage numbers, string finish reasons)
+
+type Script = "loop" | "answer" | "object" | "fail";
+type StreamPart = Awaited<ReturnType<MockLanguageModelV2["doStream"]>>["stream"] extends ReadableStream<infer P> ? P : never;
+
+const usage = (input: number, output: number) => ({ inputTokens: input, outputTokens: output, totalTokens: input + output });
+
+function scripted(script: Script = "loop") {
+  let generated = 0;
+  let streamed = 0;
+  return new MockLanguageModelV2({
+    provider: "mock-provider",
+    modelId: "mock-model",
+    doGenerate: async () => {
+      generated += 1;
+      if (script === "fail") throw new Error("model exploded");
+      if (script === "object") {
+        return { content: [{ type: "text", text: '{"city":"Paris"}' }], finishReason: "stop", usage: usage(5, 3), warnings: [] };
+      }
+      if (script === "loop" && generated === 1) {
+        return {
+          content: [{ type: "tool-call", toolCallId: "call-1", toolName: "weather", input: '{"city":"Paris"}' }],
+          finishReason: "tool-calls",
+          usage: usage(11, 7),
+          warnings: [],
+        };
+      }
+      return { content: [{ type: "text", text: "It is 20C in Paris." }], finishReason: "stop", usage: usage(23, 9), warnings: [] };
+    },
+    doStream: async () => {
+      streamed += 1;
+      if (script === "fail") throw new Error("model exploded");
+      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[] =
+        script === "object"
+          ? [{ type: "stream-start", warnings: [] }, ...text("o", '{"city":', '"Paris"}'), { type: "finish", finishReason: "stop", usage: usage(5, 3) }]
+          : script === "loop" && streamed === 1
+            ? [
+                { type: "stream-start", warnings: [] },
+                { type: "tool-call", toolCallId: "call-s1", toolName: "weather", input: '{"city":"Rome"}' },
+                { type: "finish", finishReason: "tool-calls", usage: usage(13, 4) },
+              ]
+            : [{ type: "stream-start", warnings: [] }, ...text("t", "Rome is ", "25C."), { type: "finish", finishReason: "stop", usage: usage(30, 6) }];
+      return { stream: simulateReadableStream({ chunks }) };
+    },
+  });
+}
+
+const makeTools = (fail = false) => ({
+  weather: tool({
+    description: "Current weather for a city",
+    inputSchema: 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 = { stopWhen: stepCountIs(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-5/package-lock.json

@@ -0,0 +1,156 @@
+{
+  "name": "failproofai-it-ai-5",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "failproofai-it-ai-5",
+      "dependencies": {
+        "ai": "5.0.263",
+        "zod": "4.6.5"
+      },
+      "devDependencies": {
+        "@types/node": "22.20.4"
+      }
+    },
+    "node_modules/@ai-sdk/gateway": {
+      "version": "2.0.155",
+      "resolved": "https://registry.npmjs.org/@ai-sdk/gateway/-/gateway-2.0.155.tgz",
+      "integrity": "sha512-bPy/+zFCfmkfzizBPHDhhyHUVpcGirFKkGx/SYeeWcDqQtch3CQhXFYN52oWHb66EwAo8djMSGrOJ5BTBo37Zw==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@ai-sdk/provider": "2.0.4",
+        "@ai-sdk/provider-utils": "3.0.37",
+        "@vercel/oidc": "3.1.0"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "peerDependencies": {
+        "zod": "^3.25.76 || ^4.1.8"
+      }
+    },
+    "node_modules/@ai-sdk/provider": {
+      "version": "2.0.4",
+      "resolved": "https://registry.npmjs.org/@ai-sdk/provider/-/provider-2.0.4.tgz",
+      "integrity": "sha512-B0M50w0W43jTzZGyZrNwwaK1M79aKPw6PD/dQhkBR7vkR68yCINWBo2CbBLJrbrqYc46TaiSfsTiT+S9EmVl0w==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "json-schema": "^0.4.0"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@ai-sdk/provider-utils": {
+      "version": "3.0.37",
+      "resolved": "https://registry.npmjs.org/@ai-sdk/provider-utils/-/provider-utils-3.0.37.tgz",
+      "integrity": "sha512-mLx1SgE20xKQ87xME+9uG6pFlYPTqGDrMFrZ6XcytDnmbWGwmCIh2Xb9zFrfXUrKycSFRDet4Zovj388L9b1dg==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@ai-sdk/provider": "2.0.4",
+        "@standard-schema/spec": "^1.0.0",
+        "eventsource-parser": "^3.0.6",
+        "undici": "^5.29.0"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "peerDependencies": {
+        "zod": "^3.25.76 || ^4.1.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/@standard-schema/spec": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/@standard-schema/spec/-/spec-1.1.0.tgz",
+      "integrity": "sha512-l2aFy5jALhniG5HgqrD6jXLi/rUWrKvqN/qJx6yoJsgKhblVd+iqqU4RCXavm/jPityDo5TCvKMnpjKnOriy0w==",
+      "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/@vercel/oidc": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/@vercel/oidc/-/oidc-3.1.0.tgz",
+      "integrity": "sha512-Fw28YZpRnA3cAHHDlkt7xQHiJ0fcL+NRcIqsocZQUSmbzeIKRpwttJjik5ZGanXP+vlA4SbTg+AbA3bP363l+w==",
+      "license": "Apache-2.0",
+      "engines": {
+        "node": ">= 20"
+      }
+    },
+    "node_modules/ai": {
+      "version": "5.0.263",
+      "resolved": "https://registry.npmjs.org/ai/-/ai-5.0.263.tgz",
+      "integrity": "sha512-ncQZ81dMXXpbOAuqaIxWLaqUyRHeYLvYmPO5b+Z8+LA2jaqYIohzNkF3OOlE8kZHDz4gkQwf3vO6hCVowMBPsw==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@ai-sdk/gateway": "2.0.155",
+        "@ai-sdk/provider": "2.0.4",
+        "@ai-sdk/provider-utils": "3.0.37",
+        "@opentelemetry/api": "1.9.0"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "peerDependencies": {
+        "zod": "^3.25.76 || ^4.1.8"
+      }
+    },
+    "node_modules/eventsource-parser": {
+      "version": "3.1.1",
+      "resolved": "https://registry.npmjs.org/eventsource-parser/-/eventsource-parser-3.1.1.tgz",
+      "integrity": "sha512-EKN1vKAMcZ8MlYMpaNuxN6R9yakzH6uajHcHVTqWJzvu5pWw9DyhbP35HH8MVBQ+dZjAfDxk+A8NiR9KWaXiyQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=18.0.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/undici": {
+      "version": "7.29.0",
+      "resolved": "https://registry.npmjs.org/undici/-/undici-7.29.0.tgz",
+      "integrity": "sha512-IDxfleLmmbSskfWSUATiN1nfn2rDuvnMOqb5CWR92iIfojA0Ud+ulOAAEQ57LPr9rWmsreUyf5lwyao+7GNNVw==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=20.18.1"
+      }
+    },
+    "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/zod": {
+      "version": "4.6.5",
+      "resolved": "https://registry.npmjs.org/zod/-/zod-4.6.5.tgz",
+      "integrity": "sha512-v5l/aFXZQeai4awLbOpSoHecE9UiMrnfx75tEXLjNonXVARxQ5mOeipTjROUchszUNCqnE+hqAMujRsRHsut2Q==",
+      "license": "MIT",
+      "funding": {
+        "url": "https://github.com/sponsors/colinhacks"
+      }
+    }
+  }
+}

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

@@ -0,0 +1,16 @@
+{
+  "name": "failproofai-it-ai-5",
+  "private": true,
+  "type": "module",
+  "description": "Integration fixture: Vercel AI SDK 5.x against the packed @failproofai/sdk.",
+  "dependencies": {
+    "ai": "5.0.263",
+    "zod": "4.6.5"
+  },
+  "devDependencies": {
+    "@types/node": "22.20.4"
+  },
+  "overrides": {
+    "undici": "7.29.0"
+  }
+}