@voicelayer/sdk 0.6.0 → 0.6.1

package/dist/index.js

@@ -4675,10 +4675,86 @@ var init_dist = __esm({
     init_chat_params();
   }
 });
+function runWithModelMeter(listener, fn) {
+  return meterScope.run(listener, fn);
+}
+function requestedModel(body) {
+  const model2 = body?.model;
+  return typeof model2 === "string" && model2 ? model2 : void 0;
+}
+function safely(fn) {
+  try {
+    fn();
+  } catch (err) {
+    console.warn("[voicelayer] model meter listener failed", { err: err instanceof Error ? err.message : String(err) });
+  }
+}
+function metered(target, create, byok) {
+  return async (...args) => {
+    const listener = meterScope.getStore();
+    const startedAt = Date.now();
+    const model2 = requestedModel(args[0]);
+    if (listener) safely(() => listener.started());
+    let res;
+    try {
+      res = await Reflect.apply(create, target, args);
+      return res;
+    } finally {
+      if (listener) {
+        const usage = res?.usage;
+        const record = {
+          provider: "openai",
+          model: model2 ?? res?.model ?? "unknown",
+          ...usage ? { usage: { inputTokens: usage.prompt_tokens ?? 0, outputTokens: usage.completion_tokens ?? 0 } } : {},
+          ...byok !== void 0 ? { byok } : {},
+          startedAt,
+          endedAt: Date.now()
+        };
+        safely(() => listener.finished(record));
+      }
+    }
+  };
+}
+function meteredClient(client, byok) {
+  const hit = wrapped.get(client);
+  if (hit) return hit;
+  const chat = client.chat;
+  const embeddings = client.embeddings;
+  const completionsCreate = chat ? metered(chat.completions, chat.completions.create, byok) : void 0;
+  const embeddingsCreate = embeddings ? metered(embeddings, embeddings.create, byok) : void 0;
+  const completions = chat ? new Proxy(chat.completions, { get: (t, p, r) => p === "create" ? completionsCreate : Reflect.get(t, p, r) }) : void 0;
+  const chatProxy = chat ? new Proxy(chat, { get: (t, p, r) => p === "completions" ? completions : Reflect.get(t, p, r) }) : void 0;
+  const embeddingsProxy = embeddings ? new Proxy(embeddings, { get: (t, p, r) => p === "create" ? embeddingsCreate : Reflect.get(t, p, r) }) : void 0;
+  const proxy = new Proxy(client, {
+    get(target, prop, receiver) {
+      if (prop === "chat" && chatProxy) return chatProxy;
+      if (prop === "embeddings" && embeddingsProxy) return embeddingsProxy;
+      return Reflect.get(target, prop, receiver);
+    }
+  });
+  wrapped.set(client, proxy);
+  wrapped.set(proxy, proxy);
+  return proxy;
+}
+var meterScope, wrapped;
+var init_model_meter = __esm({
+  "src/runtime/model-meter.ts"() {
+    meterScope = new AsyncLocalStorage();
+    wrapped = /* @__PURE__ */ new WeakMap();
+  }
+});
 function configureDefaultOpenAI(cred) {
   credential = cred;
   cached = null;
 }
+function configureHelperCallCredential(source) {
+  callCredentialSource = source;
+  cached = null;
+}
+function helperKeyIsCustomers() {
+  if (credential) return true;
+  return callCredentialSource !== "worker-token";
+}
 function defaultOpenAIOptions() {
   if (!credential) return {};
   return {
@@ -4686,27 +4762,31 @@ function defaultOpenAIOptions() {
     ...credential.baseURL ? { baseURL: credential.baseURL } : {}
   };
 }
-function internalChatClient(opts) {
+function internalChatClient() {
   const cred = defaultOpenAIOptions();
   return createChatClient({
     ...cred.apiKey ? { apiKey: cred.apiKey } : {},
-    ...cred.baseURL ? { baseURL: cred.baseURL } : {},
-    ...opts?.timeoutMs ? { timeoutMs: opts.timeoutMs } : {}
+    ...cred.baseURL ? { baseURL: cred.baseURL } : {}
   });
 }
 function defaultOpenAI() {
-  return scope.getStore() ?? (cached ??= internalChatClient());
+  const scoped = scope.getStore();
+  if (scoped) return meteredClient(scoped);
+  if (!cached) cached = meteredClient(internalChatClient(), helperKeyIsCustomers());
+  return cached;
 }
 function hasOpenAiKey() {
   return scope.getStore() !== void 0 || credential !== null || Boolean(process.env["OPENAI_API_KEY"]);
 }
-var credential, cached, scope;
+var credential, cached, scope, callCredentialSource;
 var init_openai_default = __esm({
   "src/runtime/openai-default.ts"() {
     init_dist();
+    init_model_meter();
     credential = null;
     cached = null;
     scope = new AsyncLocalStorage();
+    callCredentialSource = null;
   }
 });
 function ipv4Parts(ip) {
@@ -5743,7 +5823,9 @@ var init_metrics = __esm({
   }
 });
 function recordTurnLatencySpan(args) {
-  if (!Number.isFinite(args.latencyMs) || args.latencyMs <= 0)
+  if (!Number.isFinite(args.latencyMs) || args.latencyMs < 0)
+    return;
+  if (args.latencyMs === 0 && !args.allowZero)
     return;
   const attributes = {
     [ATTR.projectId]: args.projectId,
@@ -9137,19 +9219,22 @@ function parseArgs(raw) {
 }
 function defaultComplete() {
   if (!hasOpenAiKey()) return null;
-  const client = internalChatClient({ timeoutMs: RUNNER_TIMEOUT_MS });
   return async ({ model: model2, temperature, messages, tools }) => {
+    const client = defaultOpenAI();
     const res = await withHelperModelFallback({
       client,
       model: model2,
       fallbackModel: RUNNER_MODEL,
       helper: "agent runner",
-      call: (m) => client.chat.completions.create({
-        model: m,
-        ...chatCompletionParams(m, { ...temperature !== void 0 ? { temperature } : {}, reasoningEffort: "low" }),
-        messages,
-        ...tools.length ? { tools } : {}
-      }),
+      call: (m) => client.chat.completions.create(
+        {
+          model: m,
+          ...chatCompletionParams(m, { ...temperature !== void 0 ? { temperature } : {}, reasoningEffort: "low" }),
+          messages,
+          ...tools.length ? { tools } : {}
+        },
+        { timeout: RUNNER_TIMEOUT_MS }
+      ),
       warn: graphWarn
     });
     const msg = res.choices[0]?.message;
@@ -17147,9 +17232,11 @@ var UsageAccumulator = class {
   llm = /* @__PURE__ */ new Map();
   tts = /* @__PURE__ */ new Map();
   stt = /* @__PURE__ */ new Map();
-  addLlm(provider, model2, inputTokens, outputTokens) {
-    const key = `${provider}:${model2}`;
-    const entry2 = this.llm.get(key) ?? { provider, model: model2, inputTokens: 0, outputTokens: 0 };
+  // `byok` keeps a line whose payer is known (the SDK's helper calls) apart from LiveKit's own line on the same model,
+  // which the API prices by the workspace's vault keys.
+  addLlm(provider, model2, inputTokens, outputTokens, byok) {
+    const key = `${provider}:${model2}:${byok === void 0 ? "" : byok ? "byok" : "platform"}`;
+    const entry2 = this.llm.get(key) ?? { provider, model: model2, inputTokens: 0, outputTokens: 0, ...byok !== void 0 ? { byok } : {} };
     entry2.inputTokens += Math.max(0, inputTokens || 0);
     entry2.outputTokens += Math.max(0, outputTokens || 0);
     this.llm.set(key, entry2);
@@ -17269,7 +17356,11 @@ function dispatch(metrics2, ctx) {
         inputTokens: m.promptTokens,
         outputTokens: m.completionTokens
       });
-      if (typeof m.ttftMs === "number" && m.ttftMs >= 0) {
+      if (ctx.modelClock) {
+        const startAt = m.timestamp - Math.max(0, m.durationMs);
+        const waitedMs = typeof m.ttftMs === "number" && m.ttftMs >= 0 ? m.ttftMs : Math.max(0, m.durationMs);
+        ctx.modelClock.noteReplyModelTime({ startAt, endAt: startAt + waitedMs });
+      } else if (typeof m.ttftMs === "number" && m.ttftMs >= 0) {
         recordTurnLatency({ ...base, firstTokenMs: m.ttftMs });
         recordTurnLatencySpan({ ...base, stage: "llm", latencyMs: m.ttftMs });
       }
@@ -17372,7 +17463,8 @@ function createTelemetrySink(accumulator = new UsageAccumulator()) {
             sample.provider,
             sample.model ?? "unknown",
             sample.inputTokens ?? 0,
-            sample.outputTokens ?? 0
+            sample.outputTokens ?? 0,
+            sample.byok
           );
           break;
         case "tts":
@@ -17392,6 +17484,244 @@ function createTelemetrySink(accumulator = new UsageAccumulator()) {
   };
 }
 
+// src/runtime/call-model-usage.ts
+init_dist2();
+var MAX_UNTAGGED = 32;
+function createCallModelMeter(usage) {
+  let base = null;
+  let clock;
+  let untagged = [];
+  let inFlight = 0;
+  let idle = [];
+  const otel = (t) => {
+    if (base) recordLlmUsage({ ...base, ...t });
+    else if (untagged.length < MAX_UNTAGGED) untagged.push(t);
+  };
+  return {
+    listener: {
+      started() {
+        inFlight += 1;
+      },
+      finished(call) {
+        inFlight = Math.max(0, inFlight - 1);
+        try {
+          const tokens = call.usage;
+          if (tokens && tokens.inputTokens + tokens.outputTokens > 0) {
+            usage.record({
+              kind: "llm",
+              provider: call.provider,
+              model: call.model,
+              inputTokens: tokens.inputTokens,
+              outputTokens: tokens.outputTokens,
+              ...call.byok !== void 0 ? { byok: call.byok } : {}
+            });
+            otel({ provider: call.provider, model: call.model, inputTokens: tokens.inputTokens, outputTokens: tokens.outputTokens });
+          }
+          clock?.noteModelTime({ startAt: call.startedAt, endAt: call.endedAt });
+        } finally {
+          if (inFlight === 0 && idle.length > 0) {
+            const waiting = idle;
+            idle = [];
+            for (const resolve of waiting) resolve();
+          }
+        }
+      }
+    },
+    bind(b, c) {
+      base = b;
+      clock = c;
+      const early = untagged;
+      untagged = [];
+      for (const t of early) recordLlmUsage({ ...b, ...t });
+    },
+    drain(timeoutMs) {
+      if (inFlight === 0) return Promise.resolve();
+      return new Promise((resolve) => {
+        const timer = setTimeout(done, timeoutMs);
+        timer.unref?.();
+        function done() {
+          clearTimeout(timer);
+          idle = idle.filter((r) => r !== done);
+          resolve();
+        }
+        idle.push(done);
+      });
+    }
+  };
+}
+var HANGUP_DRAIN_MS = 3e3;
+async function reportUsageAtClose(opts) {
+  try {
+    await opts.meter.drain(opts.drainMs ?? HANGUP_DRAIN_MS);
+    if (opts.usage.isEmpty()) return;
+    await opts.send(opts.usage.report(opts.durationMs));
+  } catch (err) {
+    opts.warn?.("[agent] usage report failed", { err: err instanceof Error ? err.message : String(err) });
+  }
+}
+var MAX_INTERVALS_PER_TURN = 64;
+var REPLY_METRICS_WAIT_MS = 1500;
+function modelTimeWithin(intervals, from, to) {
+  const clipped = intervals.map((i) => ({ startAt: Math.max(i.startAt, from), endAt: Math.min(i.endAt, to) })).filter((i) => i.endAt > i.startAt).sort((a, b) => a.startAt - b.startAt);
+  let total = 0;
+  let runStart = -Infinity;
+  let runEnd = -Infinity;
+  for (const i of clipped) {
+    if (i.startAt > runEnd) {
+      if (runEnd > runStart) total += runEnd - runStart;
+      runStart = i.startAt;
+      runEnd = i.endAt;
+    } else if (i.endAt > runEnd) {
+      runEnd = i.endAt;
+    }
+  }
+  if (runEnd > runStart) total += runEnd - runStart;
+  return total;
+}
+var newTurn = () => ({ windowStart: 0, windowEnd: 0, intervals: [], modelReply: false, repliesPending: 0 });
+function attachTurnModelClock(session, events, ctx, deps = {}) {
+  const now = deps.now ?? Date.now;
+  const replyWaitMs = deps.replyWaitMs ?? REPLY_METRICS_WAIT_MS;
+  const base = { projectId: ctx.projectId, callId: ctx.callId, ...ctx.campaignId ? { campaignId: ctx.campaignId } : {} };
+  let phase = "idle";
+  let turn = newTurn();
+  let parked = null;
+  let outsidePending = 0;
+  let abandonedPending = 0;
+  let spokeWhileDeciding = false;
+  const safely2 = (fn) => {
+    try {
+      fn();
+    } catch (err) {
+      console.warn("[agent] turn model time record failed", { err: err instanceof Error ? err.message : String(err) });
+    }
+  };
+  const record = (t) => {
+    if (t.repliesPending > 0) return;
+    const latencyMs = modelTimeWithin(t.intervals, t.windowStart, t.windowEnd);
+    if (t.modelReply && latencyMs <= 0) return;
+    safely2(() => {
+      recordTurnLatencySpan({ ...base, stage: "llm", latencyMs, allowZero: true });
+      if (latencyMs > 0) recordTurnLatency({ ...base, firstTokenMs: latencyMs });
+    });
+  };
+  const releaseParked = () => {
+    if (!parked) return;
+    clearTimeout(parked.timer);
+    const t = parked.turn;
+    parked = null;
+    abandonedPending += t.repliesPending;
+    record(t);
+  };
+  const flush = () => {
+    if (phase === "answered") {
+      if (turn.repliesPending > 0) {
+        releaseParked();
+        const t = turn;
+        const timer = setTimeout(releaseParked, replyWaitMs);
+        timer.unref?.();
+        parked = { turn: t, timer };
+      } else {
+        record(turn);
+      }
+    } else {
+      abandonedPending += turn.repliesPending;
+    }
+    phase = "idle";
+    turn = newTurn();
+    spokeWhileDeciding = false;
+  };
+  const at = (event) => {
+    const t = event?.createdAt;
+    return typeof t === "number" ? t : now();
+  };
+  session.on(events.userStateChanged, (event) => {
+    if (event?.newState !== "speaking") return;
+    if (phase === "deciding") {
+      spokeWhileDeciding = true;
+      return;
+    }
+    flush();
+    phase = "listening";
+  });
+  session.on(events.userInputTranscribed, (event) => {
+    if (!event?.isFinal) return;
+    if (phase === "deciding" && spokeWhileDeciding) {
+      turn = { ...newTurn(), modelReply: turn.modelReply, repliesPending: turn.repliesPending, windowStart: at(event) };
+      spokeWhileDeciding = false;
+      return;
+    }
+    if (phase !== "idle" && phase !== "listening") return;
+    turn.windowStart = at(event);
+    phase = "deciding";
+  });
+  session.on(events.agentStateChanged, (event) => {
+    if (event?.newState !== "speaking" || phase !== "deciding") return;
+    turn.windowEnd = Math.max(turn.windowStart, at(event));
+    phase = "answered";
+    spokeWhileDeciding = false;
+  });
+  session.on(events.speechCreated, (event) => {
+    if (event?.source === "say") return;
+    if (phase === "deciding") {
+      turn.modelReply = true;
+      turn.repliesPending += 1;
+    } else if (phase === "answered") {
+      turn.repliesPending += 1;
+    } else {
+      outsidePending += 1;
+    }
+  });
+  const push = (t, interval) => {
+    if (t.intervals.length < MAX_INTERVALS_PER_TURN) t.intervals.push(interval);
+  };
+  return {
+    noteModelTime(interval) {
+      push(turn, interval);
+    },
+    noteReplyModelTime(interval) {
+      if (parked && parked.turn.repliesPending > 0) {
+        push(parked.turn, interval);
+        parked.turn.repliesPending -= 1;
+        if (parked.turn.repliesPending === 0) releaseParked();
+        return;
+      }
+      const inTurn = phase === "deciding" || phase === "answered";
+      if (abandonedPending > 0 && inTurn && interval.startAt < turn.windowStart) {
+        abandonedPending -= 1;
+        return;
+      }
+      if (inTurn && turn.repliesPending > 0) {
+        push(turn, interval);
+        turn.repliesPending -= 1;
+        return;
+      }
+      if (abandonedPending > 0) {
+        abandonedPending -= 1;
+        return;
+      }
+      if (outsidePending > 0 || phase === "idle" || phase === "listening") {
+        outsidePending = Math.max(0, outsidePending - 1);
+        const ttftMs = interval.endAt - interval.startAt;
+        if (ttftMs > 0) {
+          safely2(() => {
+            recordTurnLatency({ ...base, firstTokenMs: ttftMs });
+            recordTurnLatencySpan({ ...base, stage: "llm", latencyMs: ttftMs });
+          });
+        }
+        return;
+      }
+      push(turn, interval);
+    },
+    close() {
+      flush();
+    }
+  };
+}
+
+// src/agent.ts
+init_model_meter();
+
 // src/runtime/vad-tap.ts
 function tapVad(vad, opts) {
   const listeners = /* @__PURE__ */ new Set();
@@ -18417,6 +18747,8 @@ var Agent = class {
     const agentId = typeof md["agentId"] === "string" ? md["agentId"] : void 0;
     const room = job.room.name ?? void 0;
     registerTelemetryFlush(job);
+    const usageSink = createTelemetrySink();
+    const modelMeter = createCallModelMeter(usageSink);
     try {
       return await withCallContext(
         {
@@ -18427,14 +18759,16 @@ var Agent = class {
           ...agentId ? { agentId } : {},
           ...room ? { room } : {}
         },
-        () => this.runCallSpan(job)
+        // Every model call the SDK makes on its own during the call (judge, extractor, agent loop, embeddings) reports
+        // into the call's usage and latency — the meter follows all the async work the call starts (burn-down G-40).
+        () => runWithModelMeter(modelMeter.listener, () => this.runCallSpan(job, usageSink, modelMeter))
       );
     } finally {
       await flushTelemetry().catch(() => {
       });
     }
   }
-  async runCallSpan(job) {
+  async runCallSpan(job, usageSink, modelMeter) {
     const { AutoSubscribe, voice: voice3, VADEventType } = await import('@livekit/agents');
     const Events = voice3.AgentSessionEventTypes;
     await job.connect(void 0, AutoSubscribe.SUBSCRIBE_ALL);
@@ -18460,6 +18794,7 @@ var Agent = class {
     const identity = admission.resolution;
     const sdkClient = identity.kind === "ok" ? identity.identity.client : null;
     const callCredential = identity.kind === "ok" ? identity.identity.credential : null;
+    configureHelperCallCredential(callCredential?.source ?? null);
     const identityRefused = identity.kind === "refused" && (!!this.config.flowRuntime || identity.reason === "no_project_in_dispatch");
     if (identity.kind === "refused" && !identityRefused) {
       console.warn("[agent] running with no workspace credential (worker-token exchange failed)", { reason: identity.reason });
@@ -19082,12 +19417,12 @@ ${callIntent}`
         }
       }
     };
-    const usageSink = createTelemetrySink();
     const callEffects = new EffectStack({
       onDisposeError: (err) => console.warn("[agent] call-effect dispose failed", {
         err: err instanceof Error ? err.message : String(err)
       })
     });
+    let usageReported = Promise.resolve();
     session.once(Events.Close, () => {
       sessionClosed = true;
       endCallController.dispose();
@@ -19099,12 +19434,14 @@ ${callIntent}`
         void offboardParticipant(remaining.id);
       }
       const outcome = callEndOutcome(startedAt);
-      if (sdkClient && !usageSink.isEmpty()) {
-        void sdkClient.calls.reportUsage(callSync.callId, usageSink.report(outcome.durationMs)).catch((err) => {
-          console.warn("[agent] usage report failed", {
-            callId: callSync.callId,
-            err: err instanceof Error ? err.message : String(err)
-          });
+      if (sdkClient) {
+        const calls = sdkClient.calls;
+        usageReported = reportUsageAtClose({
+          meter: modelMeter,
+          usage: usageSink,
+          durationMs: outcome.durationMs,
+          send: (report) => calls.reportUsage(callSync.callId, report),
+          warn: (message, meta) => console.warn(message, { callId: callSync.callId, ...meta })
         });
       }
       void audioExperience.onCallEnd(audioCtx, outcome);
@@ -19243,9 +19580,22 @@ ${callIntent}`
       callId: callSync.callId,
       ...callCampaignId ? { campaignId: callCampaignId } : {}
     };
+    const modelClock = graphMode && !usingRealtime ? attachTurnModelClock(
+      session,
+      {
+        userStateChanged: Events.UserStateChanged,
+        userInputTranscribed: Events.UserInputTranscribed,
+        agentStateChanged: Events.AgentStateChanged,
+        speechCreated: Events.SpeechCreated
+      },
+      metricsCtx
+    ) : void 0;
+    if (modelClock) session.once(Events.Close, () => modelClock.close());
+    modelMeter.bind(metricsCtx, modelClock);
     attachMetricsBridge(session, Events.MetricsCollected, {
       ...metricsCtx,
-      usage: usageSink
+      usage: usageSink,
+      ...modelClock ? { modelClock } : {}
     });
     if (graphMode) {
       attachEndpointingProbe(
@@ -19420,6 +19770,7 @@ ${callIntent}`
         }
       }
       await waitForSessionClose;
+      await usageReported;
     } catch (err) {
       console.error("[agent] runJob failed", {
         room: job.room.name ?? null,

package/dist/runtime/text-session.d.ts

@@ -1,4 +1,4 @@
-export { b1 as EmailResolver, b2 as FlowResolver, b3 as GraphResolvers, b4 as GraphTraceEvent, b5 as KnowledgeResolver, b6 as LiveTextConversation, b7 as LiveTurnResult, b8 as PlaybookLibraryEntry, b9 as PlaybookResolver, ba as RegistryToolsResolver, bb as RunLiveTextOptions, ag as RunTextSessionOptions, ah as RunTextTranscriptOptions, ay as TextSession, az as TextTranscriptResult, n as ToolExecutor, bc as dedupeConversationEmails, bd as denyPrivateNetwork, be as privateNetworkOptInHonoured, bf as runLiveTextConversation, aZ as runTextSession, a_ as runTextTranscript, bg as runWithOpenAIScope, bh as toPlaybookResolution } from '../text-session-CoyEcdmg.js';
+export { b1 as EmailResolver, b2 as FlowResolver, b3 as GraphResolvers, b4 as GraphTraceEvent, b5 as KnowledgeResolver, b6 as LiveTextConversation, b7 as LiveTurnResult, b8 as PlaybookLibraryEntry, b9 as PlaybookResolver, ba as RegistryToolsResolver, bb as RunLiveTextOptions, ag as RunTextSessionOptions, ah as RunTextTranscriptOptions, ay as TextSession, az as TextTranscriptResult, n as ToolExecutor, bc as dedupeConversationEmails, bd as denyPrivateNetwork, be as privateNetworkOptInHonoured, bf as runLiveTextConversation, aZ as runTextSession, a_ as runTextTranscript, bg as runWithOpenAIScope, bh as toPlaybookResolution } from '../text-session-C4Z59gG4.js';
 import '@livekit/agents';
 import 'zod';
 import '../types-KqrAfY85.js';

package/dist/runtime/text-session.js

@@ -4159,9 +4159,78 @@ var init_dist = __esm({
     init_chat_params();
   }
 });
+function requestedModel(body) {
+  const model2 = body?.model;
+  return typeof model2 === "string" && model2 ? model2 : void 0;
+}
+function safely(fn) {
+  try {
+    fn();
+  } catch (err) {
+    console.warn("[voicelayer] model meter listener failed", { err: err instanceof Error ? err.message : String(err) });
+  }
+}
+function metered(target, create, byok) {
+  return async (...args) => {
+    const listener = meterScope.getStore();
+    const startedAt = Date.now();
+    const model2 = requestedModel(args[0]);
+    if (listener) safely(() => listener.started());
+    let res;
+    try {
+      res = await Reflect.apply(create, target, args);
+      return res;
+    } finally {
+      if (listener) {
+        const usage = res?.usage;
+        const record = {
+          provider: "openai",
+          model: model2 ?? res?.model ?? "unknown",
+          ...usage ? { usage: { inputTokens: usage.prompt_tokens ?? 0, outputTokens: usage.completion_tokens ?? 0 } } : {},
+          ...byok !== void 0 ? { byok } : {},
+          startedAt,
+          endedAt: Date.now()
+        };
+        safely(() => listener.finished(record));
+      }
+    }
+  };
+}
+function meteredClient(client, byok) {
+  const hit = wrapped.get(client);
+  if (hit) return hit;
+  const chat = client.chat;
+  const embeddings = client.embeddings;
+  const completionsCreate = chat ? metered(chat.completions, chat.completions.create, byok) : void 0;
+  const embeddingsCreate = embeddings ? metered(embeddings, embeddings.create, byok) : void 0;
+  const completions = chat ? new Proxy(chat.completions, { get: (t, p, r) => p === "create" ? completionsCreate : Reflect.get(t, p, r) }) : void 0;
+  const chatProxy = chat ? new Proxy(chat, { get: (t, p, r) => p === "completions" ? completions : Reflect.get(t, p, r) }) : void 0;
+  const embeddingsProxy = embeddings ? new Proxy(embeddings, { get: (t, p, r) => p === "create" ? embeddingsCreate : Reflect.get(t, p, r) }) : void 0;
+  const proxy = new Proxy(client, {
+    get(target, prop, receiver) {
+      if (prop === "chat" && chatProxy) return chatProxy;
+      if (prop === "embeddings" && embeddingsProxy) return embeddingsProxy;
+      return Reflect.get(target, prop, receiver);
+    }
+  });
+  wrapped.set(client, proxy);
+  wrapped.set(proxy, proxy);
+  return proxy;
+}
+var meterScope, wrapped;
+var init_model_meter = __esm({
+  "src/runtime/model-meter.ts"() {
+    meterScope = new AsyncLocalStorage();
+    wrapped = /* @__PURE__ */ new WeakMap();
+  }
+});
 function runWithOpenAIScope(client, fn) {
   return scope.run(client, fn);
 }
+function helperKeyIsCustomers() {
+  if (credential) return true;
+  return callCredentialSource !== "worker-token";
+}
 function defaultOpenAIOptions() {
   if (!credential) return {};
   return {
@@ -4169,27 +4238,31 @@ function defaultOpenAIOptions() {
     ...credential.baseURL ? { baseURL: credential.baseURL } : {}
   };
 }
-function internalChatClient(opts) {
+function internalChatClient() {
   const cred = defaultOpenAIOptions();
   return createChatClient({
     ...cred.apiKey ? { apiKey: cred.apiKey } : {},
-    ...cred.baseURL ? { baseURL: cred.baseURL } : {},
-    ...{}
+    ...cred.baseURL ? { baseURL: cred.baseURL } : {}
   });
 }
 function defaultOpenAI() {
-  return scope.getStore() ?? (cached ??= internalChatClient());
+  const scoped = scope.getStore();
+  if (scoped) return meteredClient(scoped);
+  if (!cached) cached = meteredClient(internalChatClient(), helperKeyIsCustomers());
+  return cached;
 }
 function hasOpenAiKey() {
   return scope.getStore() !== void 0 || credential !== null || Boolean(process.env["OPENAI_API_KEY"]);
 }
-var credential, cached, scope;
+var credential, cached, scope, callCredentialSource;
 var init_openai_default = __esm({
   "src/runtime/openai-default.ts"() {
     init_dist();
+    init_model_meter();
     credential = null;
     cached = null;
     scope = new AsyncLocalStorage();
+    callCredentialSource = null;
   }
 });
 var init_ssrf = __esm({