promptopskit 0.2.6 → 0.3.1

package/dist/index.cjs

@@ -35,7 +35,15 @@ __export(src_exports, {
   PromptOpsKit: () => PromptOpsKit,
   anthropicAdapter: () => anthropicAdapter,
   applyOverrides: () => applyOverrides,
+  applyUsageTapEntitlements: () => applyUsageTapEntitlements,
+  beginUsageTapCall: () => beginUsageTapCall,
   createPromptOpsKit: () => createPromptOpsKit,
+  createUsageTapClient: () => createUsageTapClient,
+  defaultUsageTapErrorMapper: () => defaultUsageTapErrorMapper,
+  endUsageTapCall: () => endUsageTapCall,
+  extractAnthropicUsage: () => extractAnthropicUsage,
+  extractGeminiUsage: () => extractGeminiUsage,
+  extractOpenAIUsage: () => extractOpenAIUsage,
   extractSections: () => extractSections,
   extractVariables: () => extractVariables,
   geminiAdapter: () => geminiAdapter,
@@ -47,8 +55,13 @@ __export(src_exports, {
   parsePrompt: () => parsePrompt,
   renderPrompt: () => renderPrompt,
   resolveIncludes: () => resolveIncludes,
+  runAnthropicWithUsageTap: () => runAnthropicWithUsageTap,
+  runGeminiWithUsageTap: () => runGeminiWithUsageTap,
+  runOpenAIWithUsageTap: () => runOpenAIWithUsageTap,
+  runOpenRouterWithUsageTap: () => runOpenRouterWithUsageTap,
   validateAsset: () => validateAsset,
-  validateAssetWithIncludes: () => validateAssetWithIncludes
+  validateAssetWithIncludes: () => validateAssetWithIncludes,
+  withUsageTapCall: () => withUsageTapCall
 });
 module.exports = __toCommonJS(src_exports);
 var import_promises3 = require("fs/promises");
@@ -430,22 +443,36 @@ function renderSections(asset, options = {}) {
   return result;
 }
 
+// src/providers/resolve-asset.ts
+function resolveAssetForProvider(asset, runtime = {}) {
+  if (!runtime.environment && !runtime.tier && !runtime.runtime) {
+    return asset;
+  }
+  return applyOverrides(asset, {
+    environment: runtime.environment,
+    tier: runtime.tier,
+    runtime: runtime.runtime
+  });
+}
+
 // src/providers/openai.ts
 var openaiAdapter = {
   name: "openai",
-  validate(asset) {
+  validate(asset, runtime) {
+    const resolvedAsset = resolveAssetForProvider(asset, runtime);
     const errors = [];
     const warnings = [];
-    if (!asset.model) {
+    if (!resolvedAsset.model) {
       errors.push("OpenAI adapter requires a model to be specified.");
     }
-    if (asset.reasoning?.budget_tokens !== void 0) {
+    if (resolvedAsset.reasoning?.budget_tokens !== void 0) {
       warnings.push("OpenAI uses reasoning_effort, not budget_tokens. budget_tokens will be ignored.");
     }
     return { valid: errors.length === 0, errors, warnings };
   },
   render(asset, runtime) {
-    const sections = renderSections(asset, {
+    const resolvedAsset = resolveAssetForProvider(asset, runtime);
+    const sections = renderSections(resolvedAsset, {
       variables: runtime.variables,
       strict: runtime.strict
     });
@@ -462,26 +489,26 @@ var openaiAdapter = {
       messages.push({ role: "user", content: sections.prompt_template });
     }
     const body = {
-      model: asset.model,
+      model: resolvedAsset.model,
       messages
     };
-    if (asset.sampling?.temperature !== void 0) body.temperature = asset.sampling.temperature;
-    if (asset.sampling?.top_p !== void 0) body.top_p = asset.sampling.top_p;
-    if (asset.sampling?.frequency_penalty !== void 0) body.frequency_penalty = asset.sampling.frequency_penalty;
-    if (asset.sampling?.presence_penalty !== void 0) body.presence_penalty = asset.sampling.presence_penalty;
-    if (asset.sampling?.stop !== void 0) body.stop = asset.sampling.stop;
-    if (asset.sampling?.max_output_tokens !== void 0) body.max_tokens = asset.sampling.max_output_tokens;
-    if (asset.reasoning?.effort) {
-      body.reasoning_effort = asset.reasoning.effort;
-    }
-    if (asset.response?.format === "json") {
+    if (resolvedAsset.sampling?.temperature !== void 0) body.temperature = resolvedAsset.sampling.temperature;
+    if (resolvedAsset.sampling?.top_p !== void 0) body.top_p = resolvedAsset.sampling.top_p;
+    if (resolvedAsset.sampling?.frequency_penalty !== void 0) body.frequency_penalty = resolvedAsset.sampling.frequency_penalty;
+    if (resolvedAsset.sampling?.presence_penalty !== void 0) body.presence_penalty = resolvedAsset.sampling.presence_penalty;
+    if (resolvedAsset.sampling?.stop !== void 0) body.stop = resolvedAsset.sampling.stop;
+    if (resolvedAsset.sampling?.max_output_tokens !== void 0) body.max_tokens = resolvedAsset.sampling.max_output_tokens;
+    if (resolvedAsset.reasoning?.effort) {
+      body.reasoning_effort = resolvedAsset.reasoning.effort;
+    }
+    if (resolvedAsset.response?.format === "json") {
       body.response_format = { type: "json_object" };
     }
-    if (asset.response?.stream !== void 0) {
-      body.stream = asset.response.stream;
+    if (resolvedAsset.response?.stream !== void 0) {
+      body.stream = resolvedAsset.response.stream;
     }
-    if (asset.tools && asset.tools.length > 0) {
-      body.tools = asset.tools.map((tool) => {
+    if (resolvedAsset.tools && resolvedAsset.tools.length > 0) {
+      body.tools = resolvedAsset.tools.map((tool) => {
         if (typeof tool === "string") {
           const def = runtime.toolRegistry?.[tool];
           if (def) return def;
@@ -500,7 +527,7 @@ var openaiAdapter = {
     return {
       body,
       provider: "openai",
-      model: asset.model ?? "unknown"
+      model: resolvedAsset.model ?? "unknown"
     };
   }
 };
@@ -508,25 +535,27 @@ var openaiAdapter = {
 // src/providers/anthropic.ts
 var anthropicAdapter = {
   name: "anthropic",
-  validate(asset) {
+  validate(asset, runtime) {
+    const resolvedAsset = resolveAssetForProvider(asset, runtime);
     const errors = [];
     const warnings = [];
-    if (!asset.model) {
+    if (!resolvedAsset.model) {
       errors.push("Anthropic adapter requires a model to be specified.");
     }
-    if (asset.sampling?.frequency_penalty !== void 0) {
+    if (resolvedAsset.sampling?.frequency_penalty !== void 0) {
       warnings.push("Anthropic does not support frequency_penalty. It will be ignored.");
     }
-    if (asset.sampling?.presence_penalty !== void 0) {
+    if (resolvedAsset.sampling?.presence_penalty !== void 0) {
       warnings.push("Anthropic does not support presence_penalty. It will be ignored.");
     }
-    if (asset.reasoning?.effort !== void 0) {
+    if (resolvedAsset.reasoning?.effort !== void 0) {
       warnings.push("Anthropic uses budget_tokens for thinking, not effort. effort will be mapped approximately.");
     }
     return { valid: errors.length === 0, errors, warnings };
   },
   render(asset, runtime) {
-    const sections = renderSections(asset, {
+    const resolvedAsset = resolveAssetForProvider(asset, runtime);
+    const sections = renderSections(resolvedAsset, {
       variables: runtime.variables,
       strict: runtime.strict
     });
@@ -540,31 +569,31 @@ var anthropicAdapter = {
       messages.push({ role: "user", content: sections.prompt_template });
     }
     const body = {
-      model: asset.model,
+      model: resolvedAsset.model,
       messages
     };
     if (sections.system_instructions) {
       body.system = sections.system_instructions;
     }
-    if (asset.sampling?.temperature !== void 0) body.temperature = asset.sampling.temperature;
-    if (asset.sampling?.top_p !== void 0) body.top_p = asset.sampling.top_p;
-    if (asset.sampling?.stop !== void 0) body.stop_sequences = asset.sampling.stop;
-    if (asset.sampling?.max_output_tokens !== void 0) {
-      body.max_tokens = asset.sampling.max_output_tokens;
+    if (resolvedAsset.sampling?.temperature !== void 0) body.temperature = resolvedAsset.sampling.temperature;
+    if (resolvedAsset.sampling?.top_p !== void 0) body.top_p = resolvedAsset.sampling.top_p;
+    if (resolvedAsset.sampling?.stop !== void 0) body.stop_sequences = resolvedAsset.sampling.stop;
+    if (resolvedAsset.sampling?.max_output_tokens !== void 0) {
+      body.max_tokens = resolvedAsset.sampling.max_output_tokens;
     } else {
       body.max_tokens = 4096;
     }
-    if (asset.reasoning?.budget_tokens) {
+    if (resolvedAsset.reasoning?.budget_tokens) {
       body.thinking = {
         type: "enabled",
-        budget_tokens: asset.reasoning.budget_tokens
+        budget_tokens: resolvedAsset.reasoning.budget_tokens
       };
     }
-    if (asset.response?.stream !== void 0) {
-      body.stream = asset.response.stream;
+    if (resolvedAsset.response?.stream !== void 0) {
+      body.stream = resolvedAsset.response.stream;
     }
-    if (asset.tools && asset.tools.length > 0) {
-      body.tools = asset.tools.map((tool) => {
+    if (resolvedAsset.tools && resolvedAsset.tools.length > 0) {
+      body.tools = resolvedAsset.tools.map((tool) => {
         if (typeof tool === "string") {
           const def = runtime.toolRegistry?.[tool];
           if (def) return def;
@@ -580,7 +609,7 @@ var anthropicAdapter = {
     return {
       body,
       provider: "anthropic",
-      model: asset.model ?? "unknown"
+      model: resolvedAsset.model ?? "unknown"
     };
   }
 };
@@ -588,22 +617,24 @@ var anthropicAdapter = {
 // src/providers/gemini.ts
 var geminiAdapter = {
   name: "gemini",
-  validate(asset) {
+  validate(asset, runtime) {
+    const resolvedAsset = resolveAssetForProvider(asset, runtime);
     const errors = [];
     const warnings = [];
-    if (!asset.model) {
+    if (!resolvedAsset.model) {
       errors.push("Gemini adapter requires a model to be specified.");
     }
-    if (asset.sampling?.frequency_penalty !== void 0) {
+    if (resolvedAsset.sampling?.frequency_penalty !== void 0) {
       warnings.push("Gemini does not support frequency_penalty. It will be ignored.");
     }
-    if (asset.sampling?.presence_penalty !== void 0) {
+    if (resolvedAsset.sampling?.presence_penalty !== void 0) {
       warnings.push("Gemini does not support presence_penalty. It will be ignored.");
     }
     return { valid: errors.length === 0, errors, warnings };
   },
   render(asset, runtime) {
-    const sections = renderSections(asset, {
+    const resolvedAsset = resolveAssetForProvider(asset, runtime);
+    const sections = renderSections(resolvedAsset, {
       variables: runtime.variables,
       strict: runtime.strict
     });
@@ -631,23 +662,23 @@ var geminiAdapter = {
       };
     }
     const generationConfig = {};
-    if (asset.sampling?.temperature !== void 0) generationConfig.temperature = asset.sampling.temperature;
-    if (asset.sampling?.top_p !== void 0) generationConfig.topP = asset.sampling.top_p;
-    if (asset.sampling?.max_output_tokens !== void 0) generationConfig.maxOutputTokens = asset.sampling.max_output_tokens;
-    if (asset.sampling?.stop !== void 0) generationConfig.stopSequences = asset.sampling.stop;
-    if (asset.response?.format === "json") {
+    if (resolvedAsset.sampling?.temperature !== void 0) generationConfig.temperature = resolvedAsset.sampling.temperature;
+    if (resolvedAsset.sampling?.top_p !== void 0) generationConfig.topP = resolvedAsset.sampling.top_p;
+    if (resolvedAsset.sampling?.max_output_tokens !== void 0) generationConfig.maxOutputTokens = resolvedAsset.sampling.max_output_tokens;
+    if (resolvedAsset.sampling?.stop !== void 0) generationConfig.stopSequences = resolvedAsset.sampling.stop;
+    if (resolvedAsset.response?.format === "json") {
       generationConfig.responseMimeType = "application/json";
     }
-    if (asset.reasoning?.effort) {
+    if (resolvedAsset.reasoning?.effort) {
       body.thinkingConfig = {
-        thinkingBudget: asset.reasoning.effort === "high" ? 8192 : asset.reasoning.effort === "medium" ? 4096 : 1024
+        thinkingBudget: resolvedAsset.reasoning.effort === "high" ? 8192 : resolvedAsset.reasoning.effort === "medium" ? 4096 : 1024
       };
     }
     if (Object.keys(generationConfig).length > 0) {
       body.generationConfig = generationConfig;
     }
-    if (asset.tools && asset.tools.length > 0) {
-      const functionDeclarations = asset.tools.map((tool) => {
+    if (resolvedAsset.tools && resolvedAsset.tools.length > 0) {
+      const functionDeclarations = resolvedAsset.tools.map((tool) => {
         if (typeof tool === "string") {
           const def = runtime.toolRegistry?.[tool];
           if (def) return def;
@@ -664,7 +695,7 @@ var geminiAdapter = {
     return {
       body,
       provider: "gemini",
-      model: asset.model ?? "unknown"
+      model: resolvedAsset.model ?? "unknown"
     };
   }
 };
@@ -672,8 +703,8 @@ var geminiAdapter = {
 // src/providers/openrouter.ts
 var openrouterAdapter = {
   name: "openrouter",
-  validate(asset) {
-    return openaiAdapter.validate(asset);
+  validate(asset, runtime) {
+    return openaiAdapter.validate(asset, runtime);
   },
   render(asset, runtime) {
     const result = openaiAdapter.render(asset, runtime);
@@ -934,6 +965,377 @@ var PromptCache = class {
   }
 };
 
+// src/usagetap/client.ts
+var DEFAULT_BASE_URL = "https://api.usagetap.com";
+var ACCEPT_HEADER = "application/vnd.usagetap.v1+json";
+function createUsageTapHttpError(status, body) {
+  const error = new Error(`UsageTap request failed with status ${status}`);
+  error.statusCode = status;
+  error.body = body;
+  return error;
+}
+function createUsageTapClient(config) {
+  const fetchImpl = config.fetch ?? globalThis.fetch;
+  if (!fetchImpl) {
+    throw new Error("Fetch API is not available. Provide config.fetch when creating the UsageTap client.");
+  }
+  const baseUrl = (config.baseUrl ?? DEFAULT_BASE_URL).replace(/\/$/, "");
+  async function request(path, body, init = {}) {
+    const response = await fetchImpl(`${baseUrl}${path}`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${config.apiKey}`,
+        Accept: ACCEPT_HEADER,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(body),
+      signal: init.signal
+    });
+    const text = await response.text();
+    const parsed = text ? JSON.parse(text) : {};
+    if (!response.ok) {
+      throw createUsageTapHttpError(response.status, parsed);
+    }
+    return parsed;
+  }
+  return {
+    request,
+    beginCall(begin, init) {
+      return request("/call_begin", begin, init);
+    },
+    endCall(end, init) {
+      return request("/call_end", end, init);
+    }
+  };
+}
+
+// src/usagetap/lifecycle.ts
+function isObject(value) {
+  return typeof value === "object" && value !== null;
+}
+function isInvokeResult(value) {
+  return isObject(value) && "result" in value && "usage" in value;
+}
+function getErrorStatusCode(error) {
+  if (!isObject(error)) {
+    return void 0;
+  }
+  if (typeof error.statusCode === "number") {
+    return error.statusCode;
+  }
+  if (typeof error.status === "number") {
+    return error.status;
+  }
+  if (isObject(error.response) && typeof error.response.status === "number") {
+    return error.response.status;
+  }
+  return void 0;
+}
+function attachEndErrorCause(thrownError, endError) {
+  if (thrownError instanceof Error) {
+    if (thrownError.cause === void 0) {
+      Object.defineProperty(thrownError, "cause", {
+        value: endError,
+        configurable: true,
+        writable: true
+      });
+    }
+    throw thrownError;
+  }
+  throw new AggregateError([thrownError, endError], "Vendor call failed and UsageTap call_end also failed.");
+}
+function defaultUsageTapErrorMapper(error) {
+  return {
+    code: "VENDOR_ERROR",
+    message: String(error)
+  };
+}
+function beginUsageTapCall(client, begin, init) {
+  return client.beginCall(begin, init);
+}
+function endUsageTapCall(client, end, init) {
+  return client.endCall(end, init);
+}
+async function withUsageTapCall(client, options) {
+  const begin = await beginUsageTapCall(client, options.begin, { signal: options.signal });
+  const onError = options.onError ?? defaultUsageTapErrorMapper;
+  let result;
+  let usage;
+  let thrownError;
+  const setUsage = (nextUsage) => {
+    usage = { ...usage, ...nextUsage };
+  };
+  try {
+    const invoked = await options.invoke({
+      begin,
+      setUsage,
+      signal: options.signal
+    });
+    if (isInvokeResult(invoked)) {
+      result = invoked.result;
+      setUsage(invoked.usage);
+    } else {
+      result = invoked;
+    }
+  } catch (error) {
+    thrownError = error;
+  }
+  const effectiveUsage = {
+    ...usage
+  };
+  if (thrownError) {
+    effectiveUsage.error = effectiveUsage.error ?? onError(thrownError);
+    effectiveUsage.responseStatusCode = effectiveUsage.responseStatusCode ?? getErrorStatusCode(thrownError);
+  } else {
+    effectiveUsage.responseStatusCode = effectiveUsage.responseStatusCode ?? 200;
+  }
+  let end;
+  try {
+    end = await endUsageTapCall(client, {
+      callId: begin.data.callId,
+      ...effectiveUsage
+    }, { signal: options.signal });
+  } catch (endError) {
+    if (thrownError) {
+      attachEndErrorCause(thrownError, endError);
+    }
+    throw endError;
+  }
+  if (thrownError) {
+    throw thrownError;
+  }
+  return {
+    result,
+    begin,
+    end,
+    effectiveUsage
+  };
+}
+
+// src/usagetap/providers.ts
+function cloneRequest(request) {
+  return structuredClone(request);
+}
+function isObject2(value) {
+  return typeof value === "object" && value !== null;
+}
+function isRecordArray(value) {
+  return Array.isArray(value) && value.every((item) => isObject2(item));
+}
+function isInvokeResult2(value) {
+  return isObject2(value) && "result" in value && "usage" in value;
+}
+function capabilityAllowed(allowed, capability) {
+  return allowed[capability] !== false;
+}
+function reasoningLevelOrder(level) {
+  switch (level) {
+    case "HIGH":
+      return 3;
+    case "MEDIUM":
+      return 2;
+    case "LOW":
+      return 1;
+    default:
+      return 0;
+  }
+}
+function capOpenAIReasoning(body, allowed) {
+  if (typeof body.reasoning_effort !== "string") {
+    return;
+  }
+  const current = String(body.reasoning_effort).toUpperCase();
+  const allowedLevel = allowed.reasoningLevel ?? "HIGH";
+  if (allowedLevel === "NONE") {
+    delete body.reasoning_effort;
+    return;
+  }
+  if (reasoningLevelOrder(current) > reasoningLevelOrder(allowedLevel)) {
+    body.reasoning_effort = allowedLevel.toLowerCase();
+  }
+}
+function capGeminiReasoning(body, allowed) {
+  if (allowed.reasoningLevel === "NONE") {
+    delete body.thinkingConfig;
+    return;
+  }
+  const budgets = {
+    LOW: 1024,
+    MEDIUM: 4096,
+    HIGH: 8192
+  };
+  const allowedBudget = allowed.reasoningLevel ? budgets[allowed.reasoningLevel] : void 0;
+  if (allowedBudget === void 0) {
+    return;
+  }
+  if (!isObject2(body.thinkingConfig)) {
+    body.thinkingConfig = { thinkingBudget: allowedBudget };
+    return;
+  }
+  const thinkingConfig = body.thinkingConfig;
+  if (typeof thinkingConfig.thinkingBudget === "number") {
+    thinkingConfig.thinkingBudget = Math.min(thinkingConfig.thinkingBudget, allowedBudget);
+    return;
+  }
+  thinkingConfig.thinkingBudget = allowedBudget;
+}
+function applyModelTier(request, allowed, options) {
+  const nextModel = allowed.premium && options.modelTiers?.premium ? options.modelTiers.premium : allowed.standard && options.modelTiers?.standard ? options.modelTiers.standard : void 0;
+  if (!nextModel) {
+    return;
+  }
+  request.model = nextModel;
+  if (isObject2(request.body) && "model" in request.body) {
+    request.body.model = nextModel;
+  }
+}
+function filterOpenAITools(tools, allowed, options) {
+  return tools.filter((tool) => {
+    if (tool.type === "web_search" && allowed.search === false) {
+      return false;
+    }
+    const functionDef = isObject2(tool.function) ? tool.function : void 0;
+    const name = typeof functionDef?.name === "string" ? functionDef.name : typeof tool.name === "string" ? tool.name : typeof tool.type === "string" ? tool.type : void 0;
+    if (!name) {
+      return true;
+    }
+    const capability = options.toolEntitlements?.[name];
+    return capability ? capabilityAllowed(allowed, capability) : true;
+  });
+}
+function filterAnthropicTools(tools, allowed, options) {
+  return tools.filter((tool) => {
+    const name = typeof tool.name === "string" ? tool.name : void 0;
+    if (!name) {
+      return true;
+    }
+    const capability = options.toolEntitlements?.[name];
+    return capability ? capabilityAllowed(allowed, capability) : true;
+  });
+}
+function filterGeminiTools(tools, allowed, options) {
+  return tools.map((tool) => {
+    const declarations = Array.isArray(tool.functionDeclarations) ? tool.functionDeclarations.filter((declaration) => {
+      if (!isObject2(declaration) || typeof declaration.name !== "string") {
+        return true;
+      }
+      const capability = options.toolEntitlements?.[declaration.name];
+      return capability ? capabilityAllowed(allowed, capability) : true;
+    }) : tool.functionDeclarations;
+    return {
+      ...tool,
+      functionDeclarations: declarations
+    };
+  }).filter((tool) => {
+    if (!Array.isArray(tool.functionDeclarations)) {
+      return true;
+    }
+    return tool.functionDeclarations.length > 0;
+  });
+}
+function applyUsageTapEntitlements(request, begin, options = {}) {
+  const nextRequest = cloneRequest(request);
+  const allowed = begin.data.allowed ?? {};
+  applyModelTier(nextRequest, allowed, options);
+  if (!isObject2(nextRequest.body)) {
+    return nextRequest;
+  }
+  if (nextRequest.provider === "openai" || nextRequest.provider === "openrouter") {
+    capOpenAIReasoning(nextRequest.body, allowed);
+    if (isRecordArray(nextRequest.body.tools)) {
+      nextRequest.body.tools = filterOpenAITools(nextRequest.body.tools, allowed, options);
+    }
+    return nextRequest;
+  }
+  if (nextRequest.provider === "gemini") {
+    capGeminiReasoning(nextRequest.body, allowed);
+    if (isRecordArray(nextRequest.body.tools)) {
+      nextRequest.body.tools = filterGeminiTools(nextRequest.body.tools, allowed, options);
+    }
+    return nextRequest;
+  }
+  if (nextRequest.provider === "anthropic" && isRecordArray(nextRequest.body.tools)) {
+    nextRequest.body.tools = filterAnthropicTools(nextRequest.body.tools, allowed, options);
+  }
+  return nextRequest;
+}
+function extractOpenAIUsage(response, meta = {}) {
+  const usage = isObject2(response) && isObject2(response.usage) ? response.usage : {};
+  const promptDetails = isObject2(usage.prompt_tokens_details) ? usage.prompt_tokens_details : {};
+  const completionDetails = isObject2(usage.completion_tokens_details) ? usage.completion_tokens_details : {};
+  return {
+    modelUsed: meta.modelUsed,
+    inputTokens: typeof usage.prompt_tokens === "number" ? usage.prompt_tokens : 0,
+    responseTokens: typeof usage.completion_tokens === "number" ? usage.completion_tokens : 0,
+    cachedInputTokens: typeof promptDetails.cached_tokens === "number" ? promptDetails.cached_tokens : void 0,
+    reasoningTokens: typeof completionDetails.reasoning_tokens === "number" ? completionDetails.reasoning_tokens : void 0,
+    responseStatusCode: meta.responseStatusCode ?? 200
+  };
+}
+function extractAnthropicUsage(response, meta = {}) {
+  const usage = isObject2(response) && isObject2(response.usage) ? response.usage : {};
+  return {
+    modelUsed: meta.modelUsed,
+    inputTokens: typeof usage.input_tokens === "number" ? usage.input_tokens : 0,
+    responseTokens: typeof usage.output_tokens === "number" ? usage.output_tokens : 0,
+    cachedInputTokens: typeof usage.cache_read_input_tokens === "number" ? usage.cache_read_input_tokens : void 0,
+    responseStatusCode: meta.responseStatusCode ?? 200
+  };
+}
+function extractGeminiUsage(response, meta = {}) {
+  const usage = isObject2(response) && isObject2(response.usageMetadata) ? response.usageMetadata : {};
+  return {
+    modelUsed: meta.modelUsed,
+    inputTokens: typeof usage.promptTokenCount === "number" ? usage.promptTokenCount : 0,
+    responseTokens: typeof usage.candidatesTokenCount === "number" ? usage.candidatesTokenCount : 0,
+    cachedInputTokens: typeof usage.cachedContentTokenCount === "number" ? usage.cachedContentTokenCount : void 0,
+    reasoningTokens: typeof usage.thoughtsTokenCount === "number" ? usage.thoughtsTokenCount : void 0,
+    responseStatusCode: meta.responseStatusCode ?? 200
+  };
+}
+async function runProviderWithUsageTap(client, options, defaultExtractor) {
+  let requestUsed = cloneRequest(options.request);
+  const lifecycle = await withUsageTapCall(client, {
+    begin: options.begin,
+    signal: options.signal,
+    onError: options.onError ?? defaultUsageTapErrorMapper,
+    invoke: async ({ begin, setUsage }) => {
+      requestUsed = options.entitlementMode === "apply" ? applyUsageTapEntitlements(options.request, begin, options) : cloneRequest(options.request);
+      const invoked = await options.invoke(requestUsed);
+      if (isInvokeResult2(invoked)) {
+        return invoked;
+      }
+      const response = invoked;
+      const usage = (options.extractUsage ?? defaultExtractor)(response, {
+        modelUsed: requestUsed.model,
+        responseStatusCode: 200
+      });
+      setUsage(usage);
+      return response;
+    }
+  });
+  return {
+    response: lifecycle.result,
+    begin: lifecycle.begin,
+    end: lifecycle.end,
+    requestUsed,
+    effectiveUsage: lifecycle.effectiveUsage,
+    allowed: lifecycle.begin.data.allowed ?? {}
+  };
+}
+function runOpenAIWithUsageTap(client, options) {
+  return runProviderWithUsageTap(client, options, extractOpenAIUsage);
+}
+function runOpenRouterWithUsageTap(client, options) {
+  return runProviderWithUsageTap(client, options, extractOpenAIUsage);
+}
+function runAnthropicWithUsageTap(client, options) {
+  return runProviderWithUsageTap(client, options, extractAnthropicUsage);
+}
+function runGeminiWithUsageTap(client, options) {
+  return runProviderWithUsageTap(client, options, extractGeminiUsage);
+}
+
 // src/index.ts
 function shouldIncludeContextWarningsInResult(policy) {
   return policy === void 0 || policy === "auto" || policy === "result-only" || policy === "console-and-result";
@@ -1033,7 +1435,8 @@ ${paths.map((p) => `  - ${p}`).join("\n")}`
     }
     asset = applyOverrides(asset, {
       environment: options.environment,
-      tier: options.tier
+      tier: options.tier,
+      runtime: options.runtime
     });
     return asset;
   }
@@ -1046,13 +1449,15 @@ ${paths.map((p) => `  - ${p}`).join("\n")}`
       const { asset } = parsePrompt(options.source);
       const overridden = applyOverrides(asset, {
         environment: options.environment,
-        tier: options.tier
+        tier: options.tier,
+        runtime: options.runtime
       });
       resolved = overridden;
     } else if (options.path) {
       resolved = await this.resolvePrompt(options.path, {
         environment: options.environment,
-        tier: options.tier
+        tier: options.tier,
+        runtime: options.runtime
       });
     } else {
       throw new Error('Either "path" or "source" must be provided to renderPrompt()');
@@ -1118,7 +1523,15 @@ async function renderPrompt(options) {
   PromptOpsKit,
   anthropicAdapter,
   applyOverrides,
+  applyUsageTapEntitlements,
+  beginUsageTapCall,
   createPromptOpsKit,
+  createUsageTapClient,
+  defaultUsageTapErrorMapper,
+  endUsageTapCall,
+  extractAnthropicUsage,
+  extractGeminiUsage,
+  extractOpenAIUsage,
   extractSections,
   extractVariables,
   geminiAdapter,
@@ -1130,7 +1543,12 @@ async function renderPrompt(options) {
   parsePrompt,
   renderPrompt,
   resolveIncludes,
+  runAnthropicWithUsageTap,
+  runGeminiWithUsageTap,
+  runOpenAIWithUsageTap,
+  runOpenRouterWithUsageTap,
   validateAsset,
-  validateAssetWithIncludes
+  validateAssetWithIncludes,
+  withUsageTapCall
 });
 //# sourceMappingURL=index.cjs.map