@jambonz/llm 0.4.6 → 0.5.1

package/dist/test-kit/index.d.cts

@@ -1,4 +1,4 @@
-import { b as AdapterFactory, e as AuthKind, A as AuthSpec, L as LlmAdapter, d as ApiKeyAuth, h as ClientOptions, P as PromptRequest, m as LlmEvent, M as Message, p as ToolCallEvent, o as ModelInfo, c as AdapterManifest } from '../types-DbqWrdT6.cjs';
+import { b as AdapterFactory, e as AuthKind, A as AuthSpec, L as LlmAdapter, d as ApiKeyAuth, h as ClientOptions, P as PromptRequest, m as LlmEvent, M as Message, p as ToolCallEvent, o as ModelInfo, c as AdapterManifest } from '../types-BEgQaQIb.cjs';
 
 /**
  * Named scenarios the harness must be able to stage. Each scenario configures

package/dist/test-kit/index.d.ts

@@ -1,4 +1,4 @@
-import { b as AdapterFactory, e as AuthKind, A as AuthSpec, L as LlmAdapter, d as ApiKeyAuth, h as ClientOptions, P as PromptRequest, m as LlmEvent, M as Message, p as ToolCallEvent, o as ModelInfo, c as AdapterManifest } from '../types-DbqWrdT6.js';
+import { b as AdapterFactory, e as AuthKind, A as AuthSpec, L as LlmAdapter, d as ApiKeyAuth, h as ClientOptions, P as PromptRequest, m as LlmEvent, M as Message, p as ToolCallEvent, o as ModelInfo, c as AdapterManifest } from '../types-BEgQaQIb.js';
 
 /**
  * Named scenarios the harness must be able to stage. Each scenario configures

package/dist/test-kit/index.js

@@ -78,9 +78,22 @@ async function* streamFromOpenAI(client, req, options) {
     const param = options.tokensParam ?? (needsMaxCompletionTokens(req.model) ? "max_completion_tokens" : "max_tokens");
     body[param] = effectiveMaxTokens;
   }
+  const t0 = process.hrtime.bigint();
+  let t1;
+  let t2;
   let stream;
+  let responseHeaders;
   try {
-    stream = await client.chat.completions.create(body, { signal: req.signal });
+    const apiPromise = client.chat.completions.create(body, { signal: req.signal });
+    const maybeWithResponse = apiPromise.withResponse;
+    if (typeof maybeWithResponse === "function") {
+      const result = await maybeWithResponse.call(apiPromise);
+      stream = result.data;
+      responseHeaders = result.response?.headers;
+    } else {
+      stream = await apiPromise;
+    }
+    t1 = process.hrtime.bigint();
   } catch (err) {
     if (isAbortError(err)) {
       yield { type: "end", finishReason: "aborted" };
@@ -112,6 +125,7 @@ async function* streamFromOpenAI(client, req, options) {
       const delta = choice.delta;
       const finishReason = choice.finish_reason;
       if (delta?.content) {
+        if (t2 === void 0) t2 = process.hrtime.bigint();
         yield { type: "token", text: delta.content };
       }
       if (delta?.tool_calls) {
@@ -175,6 +189,20 @@ async function* streamFromOpenAI(client, req, options) {
     ...usage ? { usage } : {},
     ...finalRawReason ? { rawReason: finalRawReason } : {}
   };
+  if (options.vendorMetadataExtractor && responseHeaders) {
+    const metadata = options.vendorMetadataExtractor(responseHeaders);
+    if (metadata && Object.keys(metadata).length > 0) {
+      endEvent.vendorMetadata = metadata;
+    }
+  }
+  if (t1 !== void 0) {
+    const t3 = process.hrtime.bigint();
+    endEvent.clientTiming = {
+      requestToHeadersMs: Number(t1 - t0) / 1e6,
+      ...t2 !== void 0 ? { headersToFirstTokenMs: Number(t2 - t1) / 1e6 } : {},
+      totalMs: Number(t3 - t0) / 1e6
+    };
+  }
   yield endEvent;
 }
 function appendOpenAIAssistantToolCall(history, toolCalls) {
@@ -302,6 +330,40 @@ function isAbortError(err) {
   return e.name === "APIUserAbortError" || e.name === "AbortError" || e.code === "ABORT_ERR" || typeof e.message === "string" && /aborted/i.test(e.message);
 }
 
+// src/adapters/_metadata.ts
+function makeMetadataExtractor(fields) {
+  return (headers) => {
+    const out = {};
+    for (const f of fields) {
+      const raw = headers.get(f.header);
+      if (raw === null || raw === void 0 || raw === "") continue;
+      if (f.numeric) {
+        const n = Number(raw);
+        if (Number.isFinite(n)) out[f.key] = n;
+      } else {
+        out[f.key] = raw;
+      }
+    }
+    return out;
+  };
+}
+function extractMetadata(fields, headers) {
+  const headersInstance = headers instanceof Headers ? headers : recordToHeaders(headers);
+  return makeMetadataExtractor(fields)(headersInstance);
+}
+function recordToHeaders(record) {
+  const h = new Headers();
+  for (const [name, value] of Object.entries(record)) {
+    if (value === void 0) continue;
+    if (Array.isArray(value)) {
+      for (const v of value) h.append(name, v);
+    } else {
+      h.set(name, value);
+    }
+  }
+  return h;
+}
+
 // src/adapters/openai/manifest.ts
 var OPENAI_KNOWN_MODELS = [
   {
@@ -403,6 +465,12 @@ var openAIManifest = {
 };
 
 // src/adapters/openai/adapter.ts
+var OPENAI_METADATA_EXTRACTOR = makeMetadataExtractor([
+  { header: "x-request-id", key: "request_id" },
+  { header: "openai-processing-ms", key: "processing_ms", numeric: true },
+  { header: "x-ratelimit-remaining-requests", key: "requests_remaining", numeric: true },
+  { header: "x-ratelimit-remaining-tokens", key: "tokens_remaining", numeric: true }
+]);
 var OpenAIAdapter = class {
   vendor = openAIManifest.vendor;
   acceptedAuth = ["apiKey"];
@@ -420,7 +488,8 @@ var OpenAIAdapter = class {
   }
   stream(req) {
     return streamFromOpenAI(this.ensureClient(), req, {
-      knownModels: openAIManifest.knownModels
+      knownModels: openAIManifest.knownModels,
+      vendorMetadataExtractor: OPENAI_METADATA_EXTRACTOR
     });
   }
   appendAssistantToolCall(history, toolCalls) {
@@ -652,6 +721,12 @@ var anthropicManifest = {
 };
 
 // src/adapters/anthropic/adapter.ts
+var ANTHROPIC_METADATA_EXTRACTOR = makeMetadataExtractor([
+  { header: "request-id", key: "request_id" },
+  { header: "anthropic-ratelimit-requests-remaining", key: "requests_remaining", numeric: true },
+  { header: "anthropic-ratelimit-input-tokens-remaining", key: "input_tokens_remaining", numeric: true },
+  { header: "anthropic-ratelimit-output-tokens-remaining", key: "output_tokens_remaining", numeric: true }
+]);
 var AnthropicAdapter = class {
   vendor = anthropicManifest.vendor;
   acceptedAuth = ["apiKey"];
@@ -686,11 +761,20 @@ var AnthropicAdapter = class {
     if (tools) body.tools = tools;
     if (req.temperature !== void 0) body.temperature = req.temperature;
     let stream;
+    let responseHeaders;
     try {
-      stream = await client.messages.create(
+      const apiPromise = client.messages.create(
         body,
         { signal: req.signal }
       );
+      const maybeWithResponse = apiPromise.withResponse;
+      if (typeof maybeWithResponse === "function") {
+        const result = await maybeWithResponse.call(apiPromise);
+        stream = result.data;
+        responseHeaders = result.response?.headers;
+      } else {
+        stream = await apiPromise;
+      }
     } catch (err) {
       if (isAbortError2(err)) {
         yield { type: "end", finishReason: "aborted" };
@@ -801,6 +885,12 @@ var AnthropicAdapter = class {
       ...usage ? { usage } : {},
       ...stopReason ? { rawReason: stopReason } : {}
     };
+    if (responseHeaders) {
+      const metadata = ANTHROPIC_METADATA_EXTRACTOR(responseHeaders);
+      if (Object.keys(metadata).length > 0) {
+        endEvent.vendorMetadata = metadata;
+      }
+    }
     yield endEvent;
   }
   appendAssistantToolCall(history, toolCalls) {
@@ -1593,6 +1683,9 @@ var vertexOpenAIManifest = {
 };
 
 // src/adapters/vertex-openai/adapter.ts
+var VERTEX_OPENAI_METADATA_EXTRACTOR = makeMetadataExtractor([
+  { header: "x-request-id", key: "request_id" }
+]);
 var VertexOpenAIAdapter = class {
   vendor = vertexOpenAIManifest.vendor;
   acceptedAuth = ["vertexServiceAccount"];
@@ -1645,7 +1738,8 @@ var VertexOpenAIAdapter = class {
       // endpoint predates `max_completion_tokens` and may not recognize it.
       // The model-id heuristic wouldn't catch a partner model named in the
       // OpenAI style (unlikely today, but defensive).
-      tokensParam: "max_tokens"
+      tokensParam: "max_tokens",
+      vendorMetadataExtractor: VERTEX_OPENAI_METADATA_EXTRACTOR
     });
   }
   appendAssistantToolCall(history, toolCalls) {
@@ -2109,6 +2203,21 @@ var BedrockAdapter = class {
       ...usage ? { usage } : {},
       ...stopReason ? { rawReason: stopReason } : {}
     };
+    const httpHeaders = response.$metadata?.httpHeaders;
+    if (httpHeaders) {
+      const metadata = extractMetadata(
+        [
+          { header: "x-amzn-bedrock-invocation-latency", key: "invocation_latency_ms", numeric: true },
+          { header: "x-amzn-bedrock-cache-read-input-token-count", key: "cache_read_input_tokens", numeric: true },
+          { header: "x-amzn-bedrock-cache-write-input-token-count", key: "cache_write_input_tokens", numeric: true },
+          { header: "x-amzn-bedrock-trace-id", key: "trace_id" }
+        ],
+        httpHeaders
+      );
+      if (Object.keys(metadata).length > 0) {
+        endEvent.vendorMetadata = metadata;
+      }
+    }
     yield endEvent;
   }
   appendAssistantToolCall(history, toolCalls) {
@@ -2360,6 +2469,14 @@ var azureOpenAIManifest = {
 };
 
 // src/adapters/azure-openai/adapter.ts
+var AZURE_OPENAI_METADATA_EXTRACTOR = makeMetadataExtractor([
+  { header: "x-ms-region", key: "region" },
+  { header: "x-ms-deployment-name", key: "deployment" },
+  { header: "apim-request-id", key: "request_id" },
+  { header: "azureml-model-session", key: "model_session" },
+  { header: "x-ratelimit-remaining-requests", key: "requests_remaining", numeric: true },
+  { header: "x-ratelimit-remaining-tokens", key: "tokens_remaining", numeric: true }
+]);
 var AzureOpenAIAdapter = class {
   vendor = azureOpenAIManifest.vendor;
   acceptedAuth = ["azureOpenAIApiKey"];
@@ -2394,7 +2511,8 @@ var AzureOpenAIAdapter = class {
   stream(req) {
     return streamFromOpenAI(this.ensureClient(), req, {
       knownModels: azureOpenAIManifest.knownModels,
-      tokensParam: "max_completion_tokens"
+      tokensParam: "max_completion_tokens",
+      vendorMetadataExtractor: AZURE_OPENAI_METADATA_EXTRACTOR
     });
   }
   appendAssistantToolCall(history, toolCalls) {
@@ -2519,6 +2637,12 @@ var groqManifest = {
 };
 
 // src/adapters/groq/adapter.ts
+var GROQ_METADATA_EXTRACTOR = makeMetadataExtractor([
+  { header: "x-request-id", key: "request_id" },
+  { header: "x-groq-region", key: "region" },
+  { header: "x-ratelimit-remaining-requests", key: "requests_remaining", numeric: true },
+  { header: "x-ratelimit-remaining-tokens", key: "tokens_remaining", numeric: true }
+]);
 var GroqAdapter = class extends OpenAIAdapter {
   vendor = groqManifest.vendor;
   init(auth, client) {
@@ -2530,6 +2654,12 @@ var GroqAdapter = class extends OpenAIAdapter {
       client
     );
   }
+  stream(req) {
+    return streamFromOpenAI(this.ensureClient(), req, {
+      knownModels: groqManifest.knownModels,
+      vendorMetadataExtractor: GROQ_METADATA_EXTRACTOR
+    });
+  }
 };
 
 // src/adapters/groq/factory.ts
@@ -2630,6 +2760,10 @@ var huggingfaceManifest = {
 };
 
 // src/adapters/huggingface/adapter.ts
+var HUGGINGFACE_METADATA_EXTRACTOR = makeMetadataExtractor([
+  { header: "x-inference-provider", key: "provider" },
+  { header: "x-request-id", key: "request_id" }
+]);
 var HuggingfaceAdapter = class extends OpenAIAdapter {
   vendor = huggingfaceManifest.vendor;
   init(auth, client) {
@@ -2641,6 +2775,12 @@ var HuggingfaceAdapter = class extends OpenAIAdapter {
       client
     );
   }
+  stream(req) {
+    return streamFromOpenAI(this.ensureClient(), req, {
+      knownModels: huggingfaceManifest.knownModels,
+      vendorMetadataExtractor: HUGGINGFACE_METADATA_EXTRACTOR
+    });
+  }
 };
 
 // src/adapters/huggingface/factory.ts