@intelli-1113/stratos-sdk 1.2.3 → 1.3.2

package/src/vercel-ai-loader.js

@@ -0,0 +1,111 @@
+// Node custom module loader: rewrite bare specifier `ai` → Stratos shim
+// that re-exports the real package with telemetry injected on generate*/stream*/embed*.
+//
+// Registered from register.js BEFORE start(), so client code needs no changes:
+//   import "@intelli-1113/stratos-sdk/register";
+//   import { generateText } from "ai";  // ← gets wrapped exports
+
+import { createRequire } from "node:module";
+import { pathToFileURL } from "node:url";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { TELEMETRY_CALL_NAMES } from "./vercel-ai-inject.js";
+
+const SHIM_URL = "stratos-sdk:ai";
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const INJECT_URL = pathToFileURL(join(__dirname, "vercel-ai-inject.js")).href;
+// The network guard (enforcement.js, installed from register.js) already
+// refuses these calls at the fetch layer once blocked — Vercel AI's own client
+// uses fetch internally, same as everyone else. This second check is
+// redundant with that but deliberately kept: it fails before Vercel AI builds
+// its request/retry/streaming machinery, and the error reads as ours rather
+// than as a generic fetch failure surfaced through their error wrapper.
+const ENFORCEMENT_URL = pathToFileURL(join(__dirname, "enforcement.js")).href;
+
+function flagEnabled(name, defaultOn = true) {
+  const v = process.env[name];
+  if (v == null || v === "") return defaultOn;
+  return !["0", "false", "off", "no"].includes(String(v).toLowerCase());
+}
+
+export async function resolve(specifier, context, nextResolve) {
+  if (!flagEnabled("STRATOS_VERCEL_AI", true)) {
+    return nextResolve(specifier, context);
+  }
+
+  // Only rewrite the bare package name. Absolute/file imports of real `ai` pass through
+  // (used by this shim to load the original module without recursion).
+  if (specifier === "ai") {
+    return {
+      shortCircuit: true,
+      url: SHIM_URL,
+      format: "module",
+    };
+  }
+  return nextResolve(specifier, context);
+}
+
+export async function load(url, context, nextLoad) {
+  if (url !== SHIM_URL) {
+    return nextLoad(url, context);
+  }
+
+  const req = createRequire(join(process.cwd(), "package.json"));
+  let realPath;
+  try {
+    realPath = req.resolve("ai");
+  } catch (err) {
+    // Consumer doesn't have `ai` — fall through to a clear error on use
+    return {
+      format: "module",
+      shortCircuit: true,
+      source: `throw new Error("[stratos] package \\"ai\\" (Vercel AI SDK) is not installed in this project");\n`,
+    };
+  }
+
+  const realUrl = pathToFileURL(realPath).href;
+  // Load real module via absolute URL (does not match specifier === "ai")
+  const real = await import(realUrl);
+  const wrapSet = new Set(TELEMETRY_CALL_NAMES);
+  const keys = Object.keys(real).filter(
+    (k) => k !== "default" && k !== "__esModule" && /^[A-Za-z_$][\w$]*$/.test(k)
+  );
+
+  let source = "";
+  source += `import * as __real from ${JSON.stringify(realUrl)};\n`;
+  source += `import { injectTelemetryOptions } from ${JSON.stringify(INJECT_URL)};\n`;
+  source += `import { isBlocked } from ${JSON.stringify(ENFORCEMENT_URL)};\n`;
+  source += `
+function __stratosWrap(fn) {
+  if (typeof fn !== "function" || fn.__stratosWrapped) return fn;
+  const wrapped = function stratosVercelAiWrap(opts, ...rest) {
+    const __b = isBlocked();
+    if (__b.blocked) {
+      throw new Error("[stratos] request blocked: " + (__b.reason || "budget or lifecycle limit reached"));
+    }
+    return fn.call(this, injectTelemetryOptions(opts), ...rest);
+  };
+  wrapped.__stratosWrapped = true;
+  try { Object.defineProperty(wrapped, "name", { value: fn.name || "stratosVercelAiWrap" }); } catch {}
+  return wrapped;
+}
+`;
+
+  for (const k of keys) {
+    if (wrapSet.has(k)) {
+      source += `export const ${k} = __stratosWrap(__real[${JSON.stringify(k)}]);\n`;
+    } else {
+      source += `export const ${k} = __real[${JSON.stringify(k)}];\n`;
+    }
+  }
+
+  if (Object.prototype.hasOwnProperty.call(real, "default")) {
+    source += `export default __real.default;\n`;
+  }
+
+  return {
+    format: "module",
+    shortCircuit: true,
+    source,
+  };
+}

package/src/vercel-ai.js

@@ -0,0 +1,62 @@
+// Vercel AI auto-telemetry orchestration for Stratos.
+// Hooks are registered from register.js (custom ESM loader) before app code runs.
+
+import { createRequire } from "node:module";
+import { pathToFileURL } from "node:url";
+import { join } from "node:path";
+import { injectTelemetryOptions, TELEMETRY_CALL_NAMES } from "./vercel-ai-inject.js";
+
+export { injectTelemetryOptions, TELEMETRY_CALL_NAMES };
+
+function resolveFromCwd(pkg) {
+  try {
+    return createRequire(join(process.cwd(), "package.json")).resolve(pkg);
+  } catch {
+    return null;
+  }
+}
+
+function flagEnabled(name, defaultOn = true) {
+  const v = process.env[name];
+  if (v == null || v === "") return defaultOn;
+  return !["0", "false", "off", "no"].includes(String(v).toLowerCase());
+}
+
+/**
+ * Optional AI SDK v7 global registerTelemetry when @ai-sdk/otel is present.
+ * Safe no-op on v5/v6.
+ */
+export async function enableVercelAiTelemetry() {
+  if (!flagEnabled("STRATOS_VERCEL_AI", true)) {
+    return { enabled: false, mode: "disabled" };
+  }
+
+  const aiPath = resolveFromCwd("ai");
+  if (!aiPath) return { enabled: false, mode: null };
+
+  try {
+    // Via our shim if loader is active, or direct file URL
+    const ai = await import(pathToFileURL(aiPath).href);
+
+    if (typeof ai.registerTelemetry === "function") {
+      const otelPath = resolveFromCwd("@ai-sdk/otel");
+      if (otelPath) {
+        try {
+          const otel = await import(pathToFileURL(otelPath).href);
+          const OpenTelemetry = otel.OpenTelemetry || otel.LegacyOpenTelemetry;
+          if (typeof OpenTelemetry === "function") {
+            ai.registerTelemetry(new OpenTelemetry());
+            return { enabled: true, mode: "registerTelemetry" };
+          }
+        } catch {
+          /* fall through */
+        }
+      }
+    }
+
+    // ESM loader path is the primary mechanism (stratos-sdk:ai shim)
+    return { enabled: true, mode: "esm-loader-shim" };
+  } catch {
+    return { enabled: true, mode: "esm-loader-shim" };
+  }
+}