@carbon-js/sdk 0.0.7 → 0.0.8

package/dist/ai/anthropic/event-factory.d.mts

@@ -6,8 +6,10 @@ import 'zod';
 type T_LlmOutput = NonNullable<T_LLMEvent["properties"]["llm"]["output"]>;
 declare class AnthropicEventFactory {
     private readonly carbonObject?;
+    private readonly baseURL?;
     constructor(args: {
         carbonObject?: T_CarbonObject;
+        baseURL?: string;
     });
     createMessageEvents(args: {
         body: MessageCreateParamsBase;

package/dist/ai/anthropic/event-factory.mjs

@@ -4,8 +4,10 @@ import { createSdkInstrumentation } from "../../core/utils/instrumentation.mjs";
 import { stringify } from "../../utils/stringify.mjs";
 class AnthropicEventFactory {
   carbonObject;
+  baseURL;
   constructor(args) {
     this.carbonObject = args.carbonObject;
+    this.baseURL = args.baseURL;
   }
   createMessageEvents(args) {
     const usage = toAnthropicAiUsage({ usage: args.message?.usage });
@@ -17,10 +19,10 @@ class AnthropicEventFactory {
         instrumentation: createSdkInstrumentation({
           sourceFunction: args.sourceFunction,
           sourcePackage: "@anthropic-ai/sdk",
-          sourceProvider: "anthropic"
+          source: "anthropic"
         }),
         llm: {
-          gateway: "anthropic",
+          ...this.baseURL ? { apiUrl: this.baseURL } : {},
           model: String(args.message?.model ?? args.body.model ?? "unknown"),
           input: {
             prompt: stringify({ value: args.body.messages }),

package/dist/ai/anthropic/fns/message-create.d.mts

@@ -6,6 +6,7 @@ import 'zod';
 import '../../../core/runtime.mjs';
 import '../../../core/transport/types.mjs';
 import '../../../core/tools/wrap-tool.mjs';
+import '../../../core/utils/call-scope.mjs';
 
 declare function createWrappedMessageCreate(args: {
     client: Anthropic;

package/dist/ai/anthropic/fns/message-create.mjs

@@ -5,7 +5,8 @@ function createWrappedMessageCreate(args) {
   return ((body, requestOptions) => {
     const { carbon: carbonObject, ...anthropicBody } = body;
     const factory = new AnthropicEventFactory({
-      carbonObject
+      carbonObject,
+      baseURL: args.client.baseURL
     });
     const startTimeMs = Date.now();
     let messagePromise;

package/dist/ai/anthropic/fns/message-stream.d.mts

@@ -6,6 +6,7 @@ import 'zod';
 import '../../../core/runtime.mjs';
 import '../../../core/transport/types.mjs';
 import '../../../core/tools/wrap-tool.mjs';
+import '../../../core/utils/call-scope.mjs';
 
 declare function createWrappedMessageStream(args: {
     client: Anthropic;

package/dist/ai/anthropic/fns/message-stream.mjs

@@ -5,7 +5,8 @@ function createWrappedMessageStream(args) {
   return ((body, requestOptions) => {
     const { carbon: carbonObject, ...anthropicBody } = body;
     const factory = new AnthropicEventFactory({
-      carbonObject
+      carbonObject,
+      baseURL: args.client.baseURL
     });
     const startTimeMs = Date.now();
     let messageStream;

package/dist/ai/anthropic/wrap.d.mts

@@ -7,6 +7,7 @@ import 'zod';
 import '../../core/runtime.mjs';
 import '../../core/transport/types.mjs';
 import '../../core/tools/wrap-tool.mjs';
+import '../../core/utils/call-scope.mjs';
 
 declare const wrapAnthropicSdk: (client: Anthropic, carbon: Carbon) => T_WrappedAnthropicSdk;
 

package/dist/ai/openai/event-factory.d.mts

@@ -7,8 +7,10 @@ import 'zod';
 type T_LlmOutput = NonNullable<T_LLMEvent["properties"]["llm"]["output"]>;
 declare class OpenAIEventFactory {
     private readonly carbonObject?;
+    private readonly baseURL?;
     constructor(args: {
         carbonObject?: T_CarbonObject;
+        baseURL?: string;
     });
     createResponseEvents(args: {
         body: Partial<ResponseCreateParamsBase>;

package/dist/ai/openai/event-factory.mjs

@@ -4,8 +4,10 @@ import { createSdkInstrumentation } from "../../core/utils/instrumentation.mjs";
 import { stringify } from "../../utils/stringify.mjs";
 class OpenAIEventFactory {
   carbonObject;
+  baseURL;
   constructor(args) {
     this.carbonObject = args.carbonObject;
+    this.baseURL = args.baseURL;
   }
   createResponseEvents(args) {
     const usage = toResponseAiUsage({ usage: args.response?.usage });
@@ -17,10 +19,10 @@ class OpenAIEventFactory {
         instrumentation: createSdkInstrumentation({
           sourceFunction: args.sourceFunction,
           sourcePackage: "openai",
-          sourceProvider: "openai"
+          source: "openai"
         }),
         llm: {
-          gateway: "openai",
+          ...this.baseURL ? { apiUrl: this.baseURL } : {},
           model: String(args.response?.model ?? args.body.model ?? "unknown"),
           input: this.createResponseLlmInput({ body: args.body }),
           output: {
@@ -49,10 +51,10 @@ class OpenAIEventFactory {
         instrumentation: createSdkInstrumentation({
           sourceFunction: args.sourceFunction,
           sourcePackage: "openai",
-          sourceProvider: "openai"
+          source: "openai"
         }),
         llm: {
-          gateway: "openai",
+          ...this.baseURL ? { apiUrl: this.baseURL } : {},
           model: String(args.completion?.model ?? args.body.model ?? "unknown"),
           input: this.createChatCompletionLlmInput({ body: args.body }),
           output: {

package/dist/ai/openai/fns/chat-completions-create.d.mts

@@ -6,6 +6,7 @@ import 'zod';
 import '../../../core/runtime.mjs';
 import '../../../core/transport/types.mjs';
 import '../../../core/tools/wrap-tool.mjs';
+import '../../../core/utils/call-scope.mjs';
 
 declare function createWrappedChatCompletionCreate(args: {
     client: OpenAI;

package/dist/ai/openai/fns/chat-completions-create.mjs

@@ -6,7 +6,8 @@ function createWrappedChatCompletionCreate(args) {
   return ((body, requestOptions) => {
     const { carbon: carbonObject, [SKIP_CAPTURE_FIELD]: skipCapture, ...openAiBody } = body;
     const factory = new OpenAIEventFactory({
-      carbonObject
+      carbonObject,
+      baseURL: args.client.baseURL
     });
     const startTimeMs = Date.now();
     const bodyWithUsage = openAiBody.stream ? {

package/dist/ai/openai/fns/chat-completions-run-tools.d.mts

@@ -6,6 +6,7 @@ import 'zod';
 import '../../../core/runtime.mjs';
 import '../../../core/transport/types.mjs';
 import '../../../core/tools/wrap-tool.mjs';
+import '../../../core/utils/call-scope.mjs';
 
 declare function createWrappedChatCompletionRunTools(args: {
     client: OpenAI;

package/dist/ai/openai/fns/chat-completions-run-tools.mjs

@@ -17,7 +17,8 @@ function createWrappedChatCompletionRunTools(args) {
       [SKIP_CAPTURE_FIELD]: true
     };
     const factory = new OpenAIEventFactory({
-      carbonObject: tracedCarbonObject
+      carbonObject: tracedCarbonObject,
+      baseURL: args.client.baseURL
     });
     const startTimeMs = Date.now();
     let runner;
@@ -87,7 +88,7 @@ function attachRunToolsCapture(args) {
           instrumentation: createSdkInstrumentation({
             sourceFunction: "chat.completions.runTools",
             sourcePackage: "openai",
-            sourceProvider: "openai"
+            source: "openai"
           }),
           startTimeMs: toolCall?.startTimeMs ?? endTimeMs,
           status: createOkStatus(),

package/dist/ai/openai/fns/chat-completions-stream.d.mts

@@ -6,6 +6,7 @@ import 'zod';
 import '../../../core/runtime.mjs';
 import '../../../core/transport/types.mjs';
 import '../../../core/tools/wrap-tool.mjs';
+import '../../../core/utils/call-scope.mjs';
 
 declare function createWrappedChatCompletionStream(args: {
     client: OpenAI;

package/dist/ai/openai/fns/chat-completions-stream.mjs

@@ -12,7 +12,8 @@ function createWrappedChatCompletionStream(args) {
       }
     };
     const factory = new OpenAIEventFactory({
-      carbonObject
+      carbonObject,
+      baseURL: args.client.baseURL
     });
     const startTimeMs = Date.now();
     let completionStream;

package/dist/ai/openai/fns/response-create.d.mts

@@ -6,6 +6,7 @@ import 'zod';
 import '../../../core/runtime.mjs';
 import '../../../core/transport/types.mjs';
 import '../../../core/tools/wrap-tool.mjs';
+import '../../../core/utils/call-scope.mjs';
 
 declare function createWrappedResponseCreate(args: {
     client: OpenAI;

package/dist/ai/openai/fns/response-create.mjs

@@ -5,7 +5,8 @@ function createWrappedResponseCreate(args) {
   return ((body, requestOptions) => {
     const { carbon: carbonObject, ...openAiBody } = body;
     const factory = new OpenAIEventFactory({
-      carbonObject
+      carbonObject,
+      baseURL: args.client.baseURL
     });
     const startTimeMs = Date.now();
     let responsePromise;

package/dist/ai/openai/fns/response-stream.d.mts

@@ -6,6 +6,7 @@ import 'zod';
 import '../../../core/runtime.mjs';
 import '../../../core/transport/types.mjs';
 import '../../../core/tools/wrap-tool.mjs';
+import '../../../core/utils/call-scope.mjs';
 
 declare function createWrappedResponseStream(args: {
     client: OpenAI;

package/dist/ai/openai/fns/response-stream.mjs

@@ -5,7 +5,8 @@ function createWrappedResponseStream(args) {
   return ((body, requestOptions) => {
     const { carbon: carbonObject, ...openAiBody } = body;
     const factory = new OpenAIEventFactory({
-      carbonObject
+      carbonObject,
+      baseURL: args.client.baseURL
     });
     const startTimeMs = Date.now();
     let responseStream;

package/dist/ai/openai/wrap.d.mts

@@ -7,6 +7,7 @@ import 'zod';
 import '../../core/runtime.mjs';
 import '../../core/transport/types.mjs';
 import '../../core/tools/wrap-tool.mjs';
+import '../../core/utils/call-scope.mjs';
 
 declare const wrapOpenAISdk: (client: OpenAI, carbon: Carbon) => T_WrappedOpenAISdk;
 

package/dist/ai/vercel/event-factory.d.mts

@@ -6,7 +6,7 @@ import 'zod';
 type T_VercelRecordingMode = "generate" | "stream";
 type T_LlmInputEvent = OnStartEvent | OnFinishEvent | OnStepStartEvent | OnStepFinishEvent | OnToolCallStartEvent | OnToolCallFinishEvent;
 type T_PendingLlmEvent = Pick<T_LLMEvent, "id" | "startTimeMs"> & {
-    gateway: NonNullable<T_LLMEvent["properties"]["llm"]["gateway"]>;
+    apiUrl?: NonNullable<T_LLMEvent["properties"]["llm"]["apiUrl"]>;
     input: NonNullable<T_LLMEvent["properties"]["llm"]["input"]>;
     model: T_LLMEvent["properties"]["llm"]["model"];
 };
@@ -36,6 +36,7 @@ declare class VercelEventFactory {
         startTimeMs?: number;
     }): T_PendingToolEvent;
     createCompletedLlmEvent(args: {
+        apiUrl?: string;
         endTimeMs: number;
         event?: OnFinishEvent | OnStepFinishEvent;
         pendingLlm: T_PendingLlmEvent;

package/dist/ai/vercel/event-factory.mjs

@@ -1,6 +1,7 @@
 import { buildLlmEvent, buildToolEvent } from "../../core/utils/build-events.mjs";
 import { EMPTY_AI_USAGE } from "../../core/utils/build-events.mjs";
 import { createSdkInstrumentation } from "../../core/utils/instrumentation.mjs";
+import { CONSTANTS } from "../../lib/constants.mjs";
 import { generateId } from "../../utils/ids.mjs";
 import { stringify } from "../../utils/stringify.mjs";
 class VercelEventFactory {
@@ -22,7 +23,6 @@ class VercelEventFactory {
         system: "",
         tools: []
       },
-      gateway: "unknown",
       model: "unknown",
       startTimeMs: args.startTimeMs ?? Date.now()
     };
@@ -41,7 +41,10 @@ class VercelEventFactory {
           tools: "tools" in args.event ? args.event.tools : void 0
         })
       },
-      gateway: args.event.model?.provider ?? "unknown",
+      // The Vercel AI Gateway is the only serving base URL we can name without an instrumented fetch;
+      // every other provider's base URL is captured via carbon.fetch, like the OpenAI/Anthropic
+      // wrappers. Ingest resolves the provider + cost from this apiUrl.
+      ...args.event.model?.provider === "gateway" ? { apiUrl: CONSTANTS.vercel.gatewayBaseUrl } : {},
       model: args.event.model?.modelId ?? "unknown",
       startTimeMs: args.startTimeMs ?? Date.now()
     };
@@ -55,6 +58,7 @@ class VercelEventFactory {
     };
   }
   createCompletedLlmEvent(args) {
+    const apiUrl = args.pendingLlm.apiUrl ?? args.apiUrl;
     return buildLlmEvent({
       context: this.carbonObject?.context,
       additionalProperties: this.carbonObject?.additionalProperties,
@@ -63,10 +67,10 @@ class VercelEventFactory {
       instrumentation: createSdkInstrumentation({
         sourceFunction: this.sourceFunction,
         sourcePackage: "ai",
-        sourceProvider: "vercel"
+        source: "vercel"
       }),
       llm: {
-        gateway: args.pendingLlm.gateway,
+        ...apiUrl ? { apiUrl } : {},
         model: args.pendingLlm.model,
         input: args.pendingLlm.input,
         output: {
@@ -94,7 +98,7 @@ class VercelEventFactory {
       instrumentation: createSdkInstrumentation({
         sourceFunction: this.sourceFunction,
         sourcePackage: "ai",
-        sourceProvider: "vercel"
+        source: "vercel"
       }),
       startTimeMs: args.pendingTool.startTimeMs,
       status: args.status,

package/dist/ai/vercel/fns/tool-loop-agent.d.mts

@@ -7,6 +7,7 @@ import 'zod';
 import '../../../core/runtime.mjs';
 import '../../../core/transport/types.mjs';
 import '../../../core/tools/wrap-tool.mjs';
+import '../../../core/utils/call-scope.mjs';
 
 type T_CreateWrappedToolLoopAgent = {
     ToolLoopAgent: typeof vercelSdk.ToolLoopAgent;

package/dist/ai/vercel/recorder.d.mts

@@ -7,6 +7,7 @@ import '../../internal/schema/events.mjs';
 import 'zod';
 import '../../core/transport/types.mjs';
 import '../../core/tools/wrap-tool.mjs';
+import '../../core/utils/call-scope.mjs';
 
 declare class VercelRecorder {
     private readonly completedEvents;
@@ -14,6 +15,7 @@ declare class VercelRecorder {
     private readonly llmEventsByStep;
     private readonly carbon;
     private readonly toolEventsById;
+    private apiUrl;
     private isRecorded;
     private startTimeMs;
     constructor(args: {
@@ -22,6 +24,8 @@ declare class VercelRecorder {
         mode: T_VercelRecordingMode;
         sourceFunction: string;
     });
+    recordApiUrl(apiUrl: string): void;
+    private completeLlm;
     createIntegration(): TelemetryIntegration;
     recordError(args: {
         error: unknown;

package/dist/ai/vercel/recorder.mjs

@@ -9,6 +9,7 @@ class VercelRecorder {
   llmEventsByStep = /* @__PURE__ */ new Map();
   carbon;
   toolEventsById = /* @__PURE__ */ new Map();
+  apiUrl;
   isRecorded = false;
   startTimeMs = Date.now();
   constructor(args) {
@@ -19,6 +20,15 @@ class VercelRecorder {
     });
     this.carbon = args.carbon;
   }
+  // T_CallScope: a Carbon-capturing provider fetch records the request URL here; the completed
+  // event carries it as `apiUrl` so ingest resolves the serving provider via genai. First request
+  // wins (retries and multi-step calls share one provider).
+  recordApiUrl(apiUrl) {
+    this.apiUrl ??= apiUrl;
+  }
+  completeLlm(args) {
+    return this.factory.createCompletedLlmEvent({ ...args, apiUrl: this.apiUrl });
+  }
   createIntegration() {
     return bindTelemetryIntegration({
       onStart: () => {
@@ -64,7 +74,7 @@ class VercelRecorder {
     this.toolEventsById.clear();
     for (const pendingLlm of this.llmEventsByStep.values()) {
       this.completedEvents.push(
-        this.factory.createCompletedLlmEvent({
+        this.completeLlm({
           endTimeMs,
           pendingLlm,
           status
@@ -74,7 +84,7 @@ class VercelRecorder {
     this.llmEventsByStep.clear();
     if (this.completedEvents.length === 0) {
       this.completedEvents.push(
-        this.factory.createCompletedLlmEvent({
+        this.completeLlm({
           endTimeMs,
           pendingLlm: this.factory.createFallbackPendingLlmEvent({
             startTimeMs: this.startTimeMs
@@ -107,7 +117,7 @@ class VercelRecorder {
     const endTimeMs = Date.now();
     for (const [stepNumber, pendingLlm] of this.llmEventsByStep) {
       this.completedEvents.push(
-        this.factory.createCompletedLlmEvent({
+        this.completeLlm({
           endTimeMs,
           event: event.steps.find((step) => step.stepNumber === stepNumber) ?? event,
           pendingLlm,
@@ -118,7 +128,7 @@ class VercelRecorder {
     this.llmEventsByStep.clear();
     if (!this.completedEvents.some((completedEvent) => completedEvent.type === "llm")) {
       this.completedEvents.push(
-        this.factory.createCompletedLlmEvent({
+        this.completeLlm({
           endTimeMs,
           event,
           pendingLlm: this.factory.createPendingLlmEvent({
@@ -179,7 +189,7 @@ class VercelRecorder {
       event: args.event
     });
     this.completedEvents.push(
-      this.factory.createCompletedLlmEvent({
+      this.completeLlm({
         endTimeMs: args.endTimeMs,
         event: args.event,
         pendingLlm,

package/dist/ai/vercel/utils/telemetry.d.mts

@@ -6,6 +6,7 @@ import '../../../internal/schema/events.mjs';
 import 'zod';
 import '../../../core/transport/types.mjs';
 import '../../../core/tools/wrap-tool.mjs';
+import '../../../core/utils/call-scope.mjs';
 import '../event-factory.mjs';
 import 'ai';
 

package/dist/ai/vercel/utils/telemetry.mjs

@@ -1,3 +1,4 @@
+import { CARBON_CALL_SCOPE } from "../../../core/utils/call-scope.mjs";
 import { isPromiseLike } from "../../../utils/promise.mjs";
 import { VercelRecorder } from "../recorder.mjs";
 const runWithCarbonTelemetry = (args) => {
@@ -12,19 +13,21 @@ const runWithCarbonTelemetry = (args) => {
     args: aiArgs,
     recorder
   });
-  try {
-    const result = args.run(aiArgsWithCarbonTelemetry);
-    if (isPromiseLike({ value: result })) {
-      return Promise.resolve(result).catch(async (error) => {
-        recorder.recordError({ error });
-        throw error;
-      });
+  return CARBON_CALL_SCOPE.run(recorder, () => {
+    try {
+      const result = args.run(aiArgsWithCarbonTelemetry);
+      if (isPromiseLike({ value: result })) {
+        return Promise.resolve(result).catch(async (error) => {
+          recorder.recordError({ error });
+          throw error;
+        });
+      }
+      return result;
+    } catch (error) {
+      recorder.recordError({ error });
+      throw error;
     }
-    return result;
-  } catch (error) {
-    recorder.recordError({ error });
-    throw error;
-  }
+  });
 };
 const addCarbonTelemetry = (args) => {
   const telemetry = args.args.experimental_telemetry;

package/dist/ai/vercel/wrap.d.mts

@@ -7,6 +7,7 @@ import 'zod';
 import '../../core/runtime.mjs';
 import '../../core/transport/types.mjs';
 import '../../core/tools/wrap-tool.mjs';
+import '../../core/utils/call-scope.mjs';
 
 declare const wrapVercelSdk: (ai: typeof vercelSdk, carbon: Carbon) => T_WrappedVercelSdk;
 

package/dist/ai.d.mts

@@ -8,6 +8,7 @@ import 'zod';
 import './core/runtime.mjs';
 import './core/transport/types.mjs';
 import './core/tools/wrap-tool.mjs';
+import './core/utils/call-scope.mjs';
 import './ai/anthropic/types.mjs';
 import '@anthropic-ai/sdk';
 import './ai/openai/types.mjs';

package/dist/core/carbon.d.mts

@@ -1,6 +1,7 @@
 import { T_CarbonObject } from './schema/carbon-object.mjs';
 import { T_CarbonRuntimeOptions } from './runtime.mjs';
 import { T_WrapToolArgs } from './tools/wrap-tool.mjs';
+import { T_FetchFn } from './utils/call-scope.mjs';
 import { T as T_LLMEvent, b as T_ToolEvent, a as T_Event } from '../internal/schema/events.mjs';
 import './transport/types.mjs';
 import 'zod';
@@ -21,6 +22,8 @@ declare class Carbon {
     }): void;
     createTraceId(): `${string}-${string}-${string}-${string}-${string}`;
     wrapTool<T_Args extends unknown[], T_Result>(args: T_WrapToolArgs<T_Args, T_Result>): (...callArgs: [...T_Args, (T_CarbonObject | undefined)?]) => T_Result;
+    readonly fetch: T_FetchFn;
+    wrapFetch(inner: T_FetchFn): T_FetchFn;
     flushPendingEvents(): Promise<void>;
 }
 

package/dist/core/carbon.mjs

@@ -1,5 +1,6 @@
 import { CarbonRuntime } from "./runtime.mjs";
 import { createWrappedTool } from "./tools/wrap-tool.mjs";
+import { CARBON_CALL_SCOPE, urlFromFetchInput } from "./utils/call-scope.mjs";
 import { generateId } from "../utils/ids.mjs";
 class Carbon {
   runtime;
@@ -26,6 +27,23 @@ class Carbon {
       }
     });
   }
+  // A drop-in `fetch` that records the real request URL of the in-flight wrapped call (so ingest
+  // resolves the serving provider from the captured base URL via genai), then delegates to the
+  // global fetch. Pass it to any AI SDK provider: `createOpenAI({ fetch: carbon.fetch })`. Resolves
+  // `globalThis.fetch` at call time so it composes with whatever else patched it (Next, Sentry, …).
+  fetch = (input, init) => {
+    CARBON_CALL_SCOPE.recordApiUrl(urlFromFetchInput(input));
+    return globalThis.fetch(input, init);
+  };
+  // Compose Carbon's URL capture with a customer's own fetch — the provider `fetch` option REPLACES
+  // the global fetch, so a customer who already passes one wraps it here:
+  // `createOpenAI({ fetch: carbon.wrapFetch(myFetch) })`.
+  wrapFetch(inner) {
+    return (input, init) => {
+      CARBON_CALL_SCOPE.recordApiUrl(urlFromFetchInput(input));
+      return inner(input, init);
+    };
+  }
   flushPendingEvents() {
     return this.runtime.shutdown();
   }

package/dist/core/tools/wrap-tool.mjs

@@ -90,7 +90,7 @@ function captureToolResult(args) {
       instrumentation: createSdkInstrumentation({
         sourceFunction: "wrapTool",
         sourcePackage: "ai",
-        sourceProvider: "vercel"
+        source: "vercel"
       }),
       startTimeMs: args.startTimeMs,
       status: args.status ?? createOkStatus(),

package/dist/core/utils/build-events.mjs

@@ -81,7 +81,7 @@ function buildBaseEvent(args) {
     instrumentation: args.instrumentation ?? createSdkInstrumentation({
       sourceFunction: "manual",
       sourcePackage: "ai",
-      sourceProvider: "vercel"
+      source: "vercel"
     }),
     startTimeMs: args.startTimeMs,
     status: args.status,

package/dist/core/utils/call-scope.d.mts

@@ -0,0 +1,11 @@
+type T_CallScope = {
+    recordApiUrl: (apiUrl: string) => void;
+};
+declare const CARBON_CALL_SCOPE: {
+    run<T_Result>(scope: T_CallScope, fn: () => T_Result): T_Result;
+    recordApiUrl(apiUrl: string): void;
+};
+type T_FetchFn = (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
+declare const urlFromFetchInput: (input: RequestInfo | URL) => string;
+
+export { CARBON_CALL_SCOPE, type T_CallScope, type T_FetchFn, urlFromFetchInput };

package/dist/core/utils/call-scope.mjs

@@ -0,0 +1,15 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+const storage = new AsyncLocalStorage();
+const CARBON_CALL_SCOPE = {
+  run(scope, fn) {
+    return storage.run(scope, fn);
+  },
+  recordApiUrl(apiUrl) {
+    storage.getStore()?.recordApiUrl(apiUrl);
+  }
+};
+const urlFromFetchInput = (input) => typeof input === "string" ? input : input instanceof URL ? input.href : input.url;
+export {
+  CARBON_CALL_SCOPE,
+  urlFromFetchInput
+};

package/dist/core/utils/instrumentation.d.mts

@@ -1,12 +1,12 @@
 import { f as T_EventBase } from '../../internal/schema/events.mjs';
 import 'zod';
 
-type T_SourceProvider = T_EventBase["instrumentation"]["sourceProvider"];
+type T_Source = T_EventBase["instrumentation"]["source"];
 type T_SourcePackage = T_EventBase["instrumentation"]["sourcePackage"];
 declare function createSdkInstrumentation(args: {
     sourceFunction?: string;
     sourcePackage: T_SourcePackage;
-    sourceProvider: T_SourceProvider;
+    source: T_Source;
 }): T_EventBase["instrumentation"];
 
 export { createSdkInstrumentation };

package/dist/core/utils/instrumentation.mjs

@@ -1,10 +1,10 @@
 function createSdkInstrumentation(args) {
   return {
-    provider: "carbon",
-    providerPackage: "sdk",
+    vendor: "carbon",
+    vendorPackage: "sdk",
     sourceFunction: args.sourceFunction,
     sourcePackage: args.sourcePackage,
-    sourceProvider: args.sourceProvider
+    source: args.source
   };
 }
 export {

package/dist/index.d.mts

@@ -6,5 +6,6 @@ export { CarbonIngestError, HttpTransport } from './core/transport/http-transpor
 export { MemoryTransport } from './core/transport/memory-transport.mjs';
 export { T_EventBatch, T_EventTransport } from './core/transport/types.mjs';
 export { T_WrapToolArgs } from './core/tools/wrap-tool.mjs';
+import './core/utils/call-scope.mjs';
 import './internal/schema/events.mjs';
 import 'zod';

package/dist/internal/schema/events.d.mts

@@ -44,9 +44,9 @@ declare const Z_EventBase: z.ZodObject<{
         }, z.core.$strip>>;
     }, z.core.$strip>;
     instrumentation: z.ZodObject<{
-        provider: z.ZodUnion<readonly [z.ZodLiteral<"carbon">]>;
-        providerPackage: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"sdk">]>>;
-        sourceProvider: z.ZodUnion<readonly [z.ZodLiteral<"openai">, z.ZodLiteral<"anthropic">, z.ZodLiteral<"vercel">]>;
+        vendor: z.ZodUnion<readonly [z.ZodLiteral<"carbon">]>;
+        vendorPackage: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"sdk">]>>;
+        source: z.ZodUnion<readonly [z.ZodLiteral<"openai">, z.ZodLiteral<"anthropic">, z.ZodLiteral<"vercel">]>;
         sourcePackage: z.ZodUnion<readonly [z.ZodLiteral<"openai">, z.ZodLiteral<"@anthropic-ai/sdk">, z.ZodLiteral<"ai">]>;
         sourceFunction: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>;
@@ -77,9 +77,9 @@ declare const Z_LLMEvent: z.ZodObject<{
         }, z.core.$strip>>;
     }, z.core.$strip>;
     instrumentation: z.ZodObject<{
-        provider: z.ZodUnion<readonly [z.ZodLiteral<"carbon">]>;
-        providerPackage: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"sdk">]>>;
-        sourceProvider: z.ZodUnion<readonly [z.ZodLiteral<"openai">, z.ZodLiteral<"anthropic">, z.ZodLiteral<"vercel">]>;
+        vendor: z.ZodUnion<readonly [z.ZodLiteral<"carbon">]>;
+        vendorPackage: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"sdk">]>>;
+        source: z.ZodUnion<readonly [z.ZodLiteral<"openai">, z.ZodLiteral<"anthropic">, z.ZodLiteral<"vercel">]>;
         sourcePackage: z.ZodUnion<readonly [z.ZodLiteral<"openai">, z.ZodLiteral<"@anthropic-ai/sdk">, z.ZodLiteral<"ai">]>;
         sourceFunction: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>;
@@ -93,8 +93,9 @@ declare const Z_LLMEvent: z.ZodObject<{
     type: z.ZodLiteral<"llm">;
     properties: z.ZodObject<{
         llm: z.ZodObject<{
-            gateway: z.ZodOptional<z.ZodString>;
             provider: z.ZodOptional<z.ZodString>;
+            apiUrl: z.ZodOptional<z.ZodString>;
+            creator: z.ZodOptional<z.ZodString>;
             model: z.ZodString;
             input: z.ZodOptional<z.ZodObject<{
                 system: z.ZodString;
@@ -159,9 +160,9 @@ declare const Z_ToolEvent: z.ZodObject<{
         }, z.core.$strip>>;
     }, z.core.$strip>;
     instrumentation: z.ZodObject<{
-        provider: z.ZodUnion<readonly [z.ZodLiteral<"carbon">]>;
-        providerPackage: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"sdk">]>>;
-        sourceProvider: z.ZodUnion<readonly [z.ZodLiteral<"openai">, z.ZodLiteral<"anthropic">, z.ZodLiteral<"vercel">]>;
+        vendor: z.ZodUnion<readonly [z.ZodLiteral<"carbon">]>;
+        vendorPackage: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"sdk">]>>;
+        source: z.ZodUnion<readonly [z.ZodLiteral<"openai">, z.ZodLiteral<"anthropic">, z.ZodLiteral<"vercel">]>;
         sourcePackage: z.ZodUnion<readonly [z.ZodLiteral<"openai">, z.ZodLiteral<"@anthropic-ai/sdk">, z.ZodLiteral<"ai">]>;
         sourceFunction: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>;
@@ -200,9 +201,9 @@ declare const Z_Event: z.ZodDiscriminatedUnion<[z.ZodObject<{
         }, z.core.$strip>>;
     }, z.core.$strip>;
     instrumentation: z.ZodObject<{
-        provider: z.ZodUnion<readonly [z.ZodLiteral<"carbon">]>;
-        providerPackage: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"sdk">]>>;
-        sourceProvider: z.ZodUnion<readonly [z.ZodLiteral<"openai">, z.ZodLiteral<"anthropic">, z.ZodLiteral<"vercel">]>;
+        vendor: z.ZodUnion<readonly [z.ZodLiteral<"carbon">]>;
+        vendorPackage: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"sdk">]>>;
+        source: z.ZodUnion<readonly [z.ZodLiteral<"openai">, z.ZodLiteral<"anthropic">, z.ZodLiteral<"vercel">]>;
         sourcePackage: z.ZodUnion<readonly [z.ZodLiteral<"openai">, z.ZodLiteral<"@anthropic-ai/sdk">, z.ZodLiteral<"ai">]>;
         sourceFunction: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>;
@@ -216,8 +217,9 @@ declare const Z_Event: z.ZodDiscriminatedUnion<[z.ZodObject<{
     type: z.ZodLiteral<"llm">;
     properties: z.ZodObject<{
         llm: z.ZodObject<{
-            gateway: z.ZodOptional<z.ZodString>;
             provider: z.ZodOptional<z.ZodString>;
+            apiUrl: z.ZodOptional<z.ZodString>;
+            creator: z.ZodOptional<z.ZodString>;
             model: z.ZodString;
             input: z.ZodOptional<z.ZodObject<{
                 system: z.ZodString;
@@ -281,9 +283,9 @@ declare const Z_Event: z.ZodDiscriminatedUnion<[z.ZodObject<{
         }, z.core.$strip>>;
     }, z.core.$strip>;
     instrumentation: z.ZodObject<{
-        provider: z.ZodUnion<readonly [z.ZodLiteral<"carbon">]>;
-        providerPackage: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"sdk">]>>;
-        sourceProvider: z.ZodUnion<readonly [z.ZodLiteral<"openai">, z.ZodLiteral<"anthropic">, z.ZodLiteral<"vercel">]>;
+        vendor: z.ZodUnion<readonly [z.ZodLiteral<"carbon">]>;
+        vendorPackage: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"sdk">]>>;
+        source: z.ZodUnion<readonly [z.ZodLiteral<"openai">, z.ZodLiteral<"anthropic">, z.ZodLiteral<"vercel">]>;
         sourcePackage: z.ZodUnion<readonly [z.ZodLiteral<"openai">, z.ZodLiteral<"@anthropic-ai/sdk">, z.ZodLiteral<"ai">]>;
         sourceFunction: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>;

package/dist/internal/schema/events.mjs

@@ -27,9 +27,11 @@ const Z_EventContext = z.object({
   userId: z.string().optional()
 });
 const Z_EventInstrumentation = z.object({
-  provider: z.union([z.literal("carbon")]),
-  providerPackage: z.union([z.literal("sdk")]).optional(),
-  sourceProvider: z.union([z.literal("openai"), z.literal("anthropic"), z.literal("vercel")]),
+  // The telemetry vendor — who produced this event. Always Carbon.
+  vendor: z.union([z.literal("carbon")]),
+  vendorPackage: z.union([z.literal("sdk")]).optional(),
+  // The SDK family the customer instrumented — the wrapper that captured the call.
+  source: z.union([z.literal("openai"), z.literal("anthropic"), z.literal("vercel")]),
   sourcePackage: z.union([z.literal("openai"), z.literal("@anthropic-ai/sdk"), z.literal("ai")]),
   sourceFunction: z.string().optional()
 });
@@ -58,8 +60,13 @@ const Z_LLMEvent = Z_EventBase.extend({
   type: z.literal("llm"),
   properties: z.object({
     llm: z.object({
-      gateway: z.string().optional(),
+      // The serving platform that executed the request (e.g. "openai", "openrouter", "vercel"),
+      // resolved at ingest from `apiUrl`. Industry term: "provider".
       provider: z.string().optional(),
+      // The API base URL the SDK captured; ingest resolves `provider` from it.
+      apiUrl: z.string().optional(),
+      // The model's maker / author (e.g. "anthropic", "alibaba"), resolved at ingest from the model id.
+      creator: z.string().optional(),
       model: z.string(),
       input: z.object({
         system: z.string(),

package/dist/lib/constants.d.mts

@@ -15,6 +15,9 @@ type T_Constants = {
     errors: {
         warnThrottleMs: number;
     };
+    vercel: {
+        gatewayBaseUrl: string;
+    };
 };
 declare const CONSTANTS: T_Constants;
 

package/dist/lib/constants.mjs

@@ -14,6 +14,11 @@ const CONSTANTS = {
   },
   errors: {
     warnThrottleMs: 6e4
+  },
+  // The Vercel AI Gateway base URL the wrapper stamps for gateway calls; ingest resolves the serving
+  // provider + cost from it (its api_pattern matches in the model catalog).
+  vercel: {
+    gatewayBaseUrl: "https://ai-gateway.vercel.sh/v1"
   }
 };
 export {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@carbon-js/sdk",
-  "version": "0.0.7",
+  "version": "0.0.8",
   "license": "MIT",
   "type": "module",
   "exports": {