@outputai/core 0.15.1-next.59eb401.0 → 0.15.1-next.8ef04e2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@outputai/core",
-  "version": "0.15.1-next.59eb401.0",
+  "version": "0.15.1-next.8ef04e2.0",
   "description": "The core module of the output framework",
   "type": "module",
   "engines": {
@@ -30,6 +30,14 @@
     "./credentials": {
       "types": "./dist/credentials/index.d.ts",
       "import": "./dist/credentials/index.js"
+    },
+    "./http": {
+      "types": "./src/http/index.d.ts",
+      "import": "./src/http/index.js"
+    },
+    "./llm": {
+      "types": "./src/llm/index.d.ts",
+      "import": "./src/llm/index.js"
     }
   },
   "files": [
@@ -37,7 +45,8 @@
     "./dist",
     "./bin",
     "!**/*.spec.*",
-    "!src/credentials"
+    "!src/credentials",
+    "!src/llm/fixtures"
   ],
   "bin": {
     "output-worker": "./bin/worker.sh",
@@ -58,20 +67,61 @@
     "@temporalio/common": "1.24.0",
     "@temporalio/worker": "1.24.0",
     "@temporalio/workflow": "1.24.0",
+    "decimal.js": "10.6.0",
+    "entities": "8.1.0",
     "folder-hash": "4.1.3",
+    "gray-matter": "4.0.3",
     "js-yaml": "5.4.2",
     "json-stream-stringify": "3.1.7",
+    "liquidjs": "10.29.0",
     "redis": "5.12.1",
     "stacktrace-parser": "0.1.11",
-    "undici": "8.11.0",
     "winston": "3.19.0"
   },
   "peerDependencies": {
-    "zod": ">=4.3 <5"
+    "zod": ">=4.3 <5",
+    "ky": ">=2 <3",
+    "undici": ">=8 <9",
+    "ai": ">=7 <8",
+    "@ai-sdk/amazon-bedrock": ">=5 <6",
+    "@ai-sdk/anthropic": ">=4 <5",
+    "@ai-sdk/azure": ">=4 <5",
+    "@ai-sdk/google-vertex": ">=5 <6",
+    "@ai-sdk/openai": ">=4 <5",
+    "@ai-sdk/perplexity": ">=4 <5"
+  },
+  "peerDependenciesMeta": {
+    "@ai-sdk/amazon-bedrock": {
+      "optional": true
+    },
+    "@ai-sdk/anthropic": {
+      "optional": true
+    },
+    "@ai-sdk/azure": {
+      "optional": true
+    },
+    "@ai-sdk/google-vertex": {
+      "optional": true
+    },
+    "@ai-sdk/openai": {
+      "optional": true
+    },
+    "@ai-sdk/perplexity": {
+      "optional": true
+    }
   },
   "devDependencies": {
     "@types/js-yaml": "4.0.9",
-    "zod": "4.6.5"
+    "zod": "4.6.5",
+    "ky": "2.0.2",
+    "undici": "8.10.2",
+    "ai": "7.0.112",
+    "@ai-sdk/amazon-bedrock": "5.0.92",
+    "@ai-sdk/anthropic": "4.0.61",
+    "@ai-sdk/azure": "4.0.77",
+    "@ai-sdk/google-vertex": "5.0.91",
+    "@ai-sdk/openai": "4.0.73",
+    "@ai-sdk/perplexity": "4.0.49"
   },
   "license": "Apache-2.0",
   "publishConfig": {
@@ -83,6 +133,7 @@
     "#credentials/*": "./dist/credentials/*.js",
     "#errors": "./src/errors.js",
     "#logger": "./src/logger/index.js",
+    "#runtime_logger": "./src/interface/logger.js",
     "#hooks/*": "./src/hooks/*.js",
     "#helpers/*": "./src/helpers/*.js",
     "#tracing": "./src/tracing/internal_interface.js",
@@ -93,6 +144,7 @@
   },
   "scripts": {
     "worker": "node ./src/worker/index.js",
-    "build": "rm -rf ./dist && tsc && pnpm exec tsc -p ./tsconfig.typecheck.json"
+    "build": "rm -rf ./dist && tsc && pnpm exec tsc -p ./tsconfig.typecheck.json",
+    "take-models-pricing-snapshot": "node ./scripts/take_models_pricing_snapshot.js"
   }
 }

package/src/helpers/fetch.js

@@ -1,19 +1,31 @@
 import { FatalError } from '#errors';
 import { redactHeaders } from './redact.js';
 
+const jsonMatcher = /^application\/(?:json|[^;\s]+?\+json)(?:\s*;.*)?$/i;
+const textMatcher = /^(?:text\/|application\/(?:xml|[^;\s]+?\+xml|x-www-form-urlencoded|javascript)(?:\s*;|$))/i;
+
 /**
- * Consume the body of a Response according it its content-type and returns it
+ * Consume the body of a Response according it its content-type and returns it:
+ * - JSON content-type: parsed JSON, or the raw text if the body is empty or not valid JSON
+ * - text-like content-type: the text as-is
+ * - anything else: the body bytes as a base64 string
  * @param {Response} response
- * @returns {string|object|undefined|null} The response body content
+ * @returns {string|object|null} The response body content
  */
-const consumeBody = async response => {
-  const headers = Object.fromEntries( response.headers ) ?? {};
-  const contentType = ( headers['content-type'] ?? '' ).trim().toLowerCase();
-  const jsonMatcher = /^application\/(?:json|[^;\s]+?\+json)(?:\s*;.*)?$/i;
+export const consumeBody = async response => {
+  const contentType = ( response.headers.get( 'content-type' ) ?? '' ).trim();
   if ( jsonMatcher.test( contentType ) ) {
-    return response.json();
+    const text = await response.text();
+    if ( text.length === 0 ) {
+      return text;
+    }
+    try {
+      return JSON.parse( text );
+    } catch {
+      return text;
+    }
   }
-  if ( contentType.startsWith( 'text/' ) ) {
+  if ( textMatcher.test( contentType ) ) {
     return response.text();
   }
   return response.arrayBuffer().then( buf => Buffer.from( buf ).toString( 'base64' ) );
@@ -33,7 +45,7 @@ export const serializeResponse = async ( response, { includeHeaders = false, inc
   status: response.status,
   statusText: response.statusText,
   ok: response.ok,
-  ...( includeHeaders && { headers: redactHeaders( Object.fromEntries( response.headers ) ) } ),
+  ...( includeHeaders && { headers: redactHeaders( response.headers ) } ),
   ...( includeBody && { body: await consumeBody( response ) } )
 } );
 

package/src/helpers/path.js

@@ -0,0 +1,36 @@
+import * as stackTraceParser from 'stacktrace-parser';
+
+// OS separator, but in a deterministic way, allowing this to work in Temporal's sandbox
+// This avoids importing from node:path
+const SEP = new Error().stack.includes( '/' ) ? '/' : '\\';
+const transformSeparators = path => path.replaceAll( '/', SEP );
+
+const defaultIgnorePaths = [
+  '/@outputai/core/',
+  '/@outputai/evals/',
+  '/sdk/core/',
+  '/sdk/evals/',
+  'node:internal/',
+  'evalmachine.',
+  'webpack/bootstrap'
+];
+
+/**
+ * Return the first immediate directory of the file invoking the code that called this function.
+ *
+ * Excludes `@outputai/core`, node, other internal paths, and any additional ignore paths.
+ *
+ * @param {string[]} [additionalIgnorePaths]
+ * @returns {string}
+ */
+export const resolveInvocationDir = ( additionalIgnorePaths = [] ) => {
+  const stack = new Error().stack;
+  const lines = stackTraceParser.parse( stack );
+  const ignorePaths = [ ...additionalIgnorePaths, ...defaultIgnorePaths ].map( transformSeparators );
+
+  const frame = lines.find( l => !ignorePaths.some( p => l.file.includes( p ) ) );
+  if ( !frame ) {
+    throw new Error( `Invocation dir resolution via stack trace failed. Stack: ${stack}` );
+  }
+  return frame.file.replace( 'file://', '' ).split( SEP ).slice( 0, -1 ).join( SEP );
+};

package/src/helpers/redact.js

@@ -43,7 +43,8 @@ export const redactHeaders = headers => {
     wordEndMatcher( 'key' )
   ];
 
-  return Object.entries( headers ).reduce( ( redacted, [ key, value ] ) => {
+  const plainHeaders = Object.fromEntries( headers );
+  return Object.entries( plainHeaders ).reduce( ( redacted, [ key, value ] ) => {
     const lowKey = key.toLowerCase();
     const isSensitive = !ignoreHeaders.has( lowKey ) && sensitiveHeadersPatterns.some( rx => rx.test( lowKey ) );
     return Object.assign( redacted, { [key]: isSensitive ? '[REDACTED]' : value } );

package/src/http/config.js

@@ -0,0 +1,10 @@
+/**
+ * Configuration for HTTP client behavior
+ */
+export const config = {
+  /**
+   * Whether to log verbose HTTP information (headers and bodies)
+   * Controlled by OUTPUT_TRACE_HTTP_VERBOSE environment variable
+   */
+  logVerbose: [ '1', 'true' ].includes( process.env.OUTPUT_TRACE_HTTP_VERBOSE )
+};

package/src/http/cost.d.ts

@@ -0,0 +1,20 @@
+import type { KyResponse } from 'ky';
+import { Attribute } from '#trace_attribute';
+
+/** Trace attribute (`http:request:cost`) holding the cost attached to an HTTP request with `addRequestCost` */
+export declare class HTTPRequestCost extends Attribute.BaseAttribute {
+  static TYPE: 'http:request:cost';
+  type: typeof HTTPRequestCost.TYPE;
+  url: string;
+  requestId: string;
+  total: number;
+  constructor( url: string, requestId: string, total: number );
+}
+
+/**
+ * Attach cost information to the trace of an HTTP Request using the response
+ *
+ * @param response - The response of the HTTP Request to attach the information
+ * @param value - The price of the HTTP request
+ */
+export declare function addRequestCost( response: KyResponse | Response, value: number ): void;

package/src/http/cost.js

@@ -0,0 +1,41 @@
+import { stepEventBus } from '#bus';
+import { requestIdSymbol } from './request_tag.js';
+import { Logger } from '#runtime_logger';
+import { addEventActionWithContext, EventAction } from '#tracing';
+import { BaseAttribute } from '#trace_attribute';
+
+export class HTTPRequestCost extends BaseAttribute {
+  static TYPE = 'http:request:cost';
+  url;
+  requestId;
+  total = 0;
+
+  constructor( url, requestId, total ) {
+    super( HTTPRequestCost.TYPE );
+    this.url = url;
+    this.requestId = requestId;
+    this.total = total;
+  }
+}
+
+/**
+ * Attach cost information to the trace of an HTTP Request using the response
+ *
+ * @param {Response} response - The response of the HTTP Request to attach the information
+ * @param {number} value - The price of the HTTP request
+ * @returns {void}
+ */
+export const addRequestCost = ( response, value ) => {
+  const eventId = Reflect.get( response, requestIdSymbol );
+  if ( !eventId ) {
+    Logger.warn(
+      'addRequestCost(): The "response" argument did not originate from @outputai/core/http, no costs were added.',
+      { namespace: 'HTTP' }
+    );
+    return;
+  }
+
+  const attribute = new HTTPRequestCost( response.url, eventId, value );
+  addEventActionWithContext( EventAction.ADD_ATTR, { id: eventId, details: attribute } );
+  stepEventBus.emit( 'sdk:cost:http:request', attribute );
+};

package/src/http/fetch/events.js

@@ -0,0 +1,10 @@
+import { stepEventBus } from '#bus';
+
+export const emitError = ( { requestId, method, url, status, durationMs } ) =>
+  stepEventBus.emit( 'sdk:http:request', { requestId, method, url, status, durationMs, outcome: 'error' } );
+
+export const emitSuccess = ( { requestId, method, url, status, durationMs } ) =>
+  stepEventBus.emit( 'sdk:http:request', { requestId, method, url, status, durationMs, outcome: 'success' } );
+
+export const emitFailure = ( { requestId, method, url, durationMs } ) =>
+  stepEventBus.emit( 'sdk:http:request', { requestId, method, url, status: undefined, durationMs, outcome: 'failure' } );

package/src/http/fetch/index.d.ts

@@ -0,0 +1,26 @@
+import type * as undici from 'undici';
+
+type NodeRequestInfo = string | URL | globalThis.Request;
+type NodeRequestInit = globalThis.RequestInit & Pick<undici.RequestInit, 'dispatcher'>;
+
+type OutputFetch = {
+  ( input: NodeRequestInfo, init?: NodeRequestInit ): Promise<Response>;
+  ( input: undici.RequestInfo, init?: undici.RequestInit ): Promise<Response>;
+};
+
+/**
+ * A fetch compliant function, that wraps undici's fetch.
+ *
+ * Behaves the same as any fetch function except:
+ * - Sets a request header called `x-request-trace-id` with a random UUID;
+ * - Sends the request, response, error and/or failure to the Trace system;
+ * - Emits a `http:request` event on every call (success, error, failure).
+ *
+ * Node and Undici realms can't be mixed: passing a Node `Request` with an Undici `FormData` body (or vice versa) throws a `TypeError`.
+ *
+ * @see {@link https://fetch.spec.whatwg.org/}
+ * @param input - URL string, URL object or Request object (undici's or Node's)
+ * @param init - Request options
+ * @returns The HTTP response
+ */
+export declare const outputFetch: OutputFetch;

package/src/http/fetch/index.js

@@ -0,0 +1,78 @@
+import { randomUUID } from 'node:crypto';
+import { logRequest, logResponse, logError, logFailure } from './logger.js';
+import { emitSuccess, emitError, emitFailure } from './events.js';
+import { addRequestIdToResponse } from '../request_tag.js';
+import * as undici from 'undici';
+
+/* Ignore HTTP/2. Check: https://github.com/growthxai/output/issues/299 */
+const customDispatcher = new undici.EnvHttpProxyAgent( { allowH2: false } );
+
+const createUndiciRequest = ( input, init ) => {
+  const isNodeRequest = input instanceof globalThis.Request;
+  const hasNodeFormData = init?.body instanceof globalThis.FormData;
+  const isUndiciRequest = input instanceof undici.Request;
+  const hasUndiciFormData = init?.body instanceof undici.FormData;
+
+  if ( ( isNodeRequest && hasUndiciFormData ) || ( isUndiciRequest && hasNodeFormData ) ) {
+    throw new TypeError( 'Cannot mix Node and Undici Request/FormData realms.' );
+  }
+
+  if ( !isNodeRequest && !hasNodeFormData ) {
+    return new undici.Request( input, init );
+  }
+
+  const request = new globalThis.Request( input, init );
+  return new undici.Request( request.url, request );
+};
+
+/**
+ * A fetch compliant function, that wraps undici's fetch.
+ *
+ * @param {RequestInfo} input - URL string, URL object or Request object (undici's or Node's)
+ * @param {RequestInit} [init] - Request options
+ * @returns {Promise<Response>} The HTTP response
+ */
+export const outputFetch = async ( input, init ) => {
+  const { dispatcher: inputDispatcher, ...requestInit } = init ?? {};
+
+  // Creates a Request object with the many shapes RequestInfo can have
+  const base = createUndiciRequest( input, requestInit );
+
+  // Creates a headers object with the many shapes Request.Headers can have (object, array, Headers)
+  const headers = new undici.Headers( base.headers );
+
+  const requestId = randomUUID();
+  headers.set( 'x-request-trace-id', requestId );
+  const request = new undici.Request( base, { headers } );
+
+  const method = request.method;
+  const url = request.url;
+  const startedAt = Date.now();
+
+  await logRequest( { requestId, request } );
+
+  // this allows for users not only to override the dispatcher but also to define it as undefined and remove it altogether.
+  const dispatcher = Object.hasOwn( init ?? {}, 'dispatcher' ) ? inputDispatcher : customDispatcher;
+  try {
+    const response = await undici.fetch( request, dispatcher ? { dispatcher } : undefined );
+    const durationMs = Date.now() - startedAt;
+    const { status } = response;
+
+    // This enriches the response of the request id, so it is identifiable later.
+    addRequestIdToResponse( response, requestId );
+
+    if ( status > 399 ) {
+      await logError( { requestId, response } );
+      emitError( { requestId, method, url, status, durationMs } );
+      return response;
+    }
+    await logResponse( { requestId, response } );
+    emitSuccess( { requestId, method, url, status, durationMs } );
+    return response;
+  } catch ( error ) {
+    const durationMs = Date.now() - startedAt;
+    logFailure( { requestId, error } );
+    emitFailure( { requestId, method, url, durationMs } );
+    throw error;
+  }
+};

package/src/http/fetch/logger.d.ts

@@ -0,0 +1,10 @@
+import { Attribute } from '#trace_attribute';
+
+/** Trace attribute (`http:request:count`) added to every HTTP request made with `outputFetch` or `createKyClient` */
+export declare class HTTPRequestCount extends Attribute.BaseAttribute {
+  static TYPE: 'http:request:count';
+  type: typeof HTTPRequestCount.TYPE;
+  url: string;
+  requestId: string;
+  constructor( url: string, requestId: string );
+}

package/src/http/fetch/logger.js

@@ -0,0 +1,56 @@
+import { addEventActionWithContext, EventAction } from '#tracing';
+import { BaseAttribute } from '#trace_attribute';
+import { config } from '../config.js';
+import { redactHeaders } from '#helpers/redact';
+import { consumeBody } from '#helpers/fetch';
+
+export class HTTPRequestCount extends BaseAttribute {
+  static TYPE = 'http:request:count';
+  url;
+  requestId;
+
+  constructor( url, requestId ) {
+    super( HTTPRequestCount.TYPE );
+    this.url = url;
+    this.requestId = requestId;
+  }
+}
+
+/**
+ * Sends the trace start event for an http request
+ *
+ * @param options
+ * @param options.requestId - id of the request
+ * @param options.request - The HTTP Request object
+ */
+export const logRequest = async ( { requestId, request } ) => {
+  addEventActionWithContext( EventAction.START, {
+    id: requestId, kind: 'http', name: 'request', details: {
+      method: request.method,
+      url: request.url,
+      ...( config.logVerbose && { headers: redactHeaders( request.headers ), body: await consumeBody( request.clone() ) } )
+    }
+  } );
+  addEventActionWithContext( EventAction.ADD_ATTR, { id: requestId, details: new HTTPRequestCount( request.url, requestId ) } );
+};
+
+export const logError = async ( { requestId, response } ) =>
+  addEventActionWithContext( EventAction.ERROR, {
+    id: requestId, details: {
+      status: response.status,
+      statusText: response.statusText,
+      ...( config.logVerbose && { headers: redactHeaders( response.headers ), body: await consumeBody( response.clone() ) } )
+    }
+  } );
+
+export const logResponse = async ( { requestId, response } ) =>
+  addEventActionWithContext( EventAction.END, {
+    id: requestId, details: {
+      status: response.status,
+      statusText: response.statusText,
+      ...( config.logVerbose && { headers: redactHeaders( response.headers ), body: await consumeBody( response.clone() ) } )
+    }
+  } );
+
+export const logFailure = ( { requestId, error } ) =>
+  addEventActionWithContext( EventAction.ERROR, { id: requestId, details: error } );

package/src/http/index.d.ts

@@ -0,0 +1,27 @@
+/** Payload of the `http:request` event */
+export type HttpRequestEvent = {
+  requestId: string;
+  method: string;
+  url: string;
+  status: number | undefined;
+  durationMs: number;
+  outcome: 'success' | 'error' | 'failure';
+};
+
+/** Payload of the `cost:http:request` event */
+export type HttpRequestCostEvent = {
+  type: 'http:request:cost';
+  requestId: string;
+  url: string;
+  total: number;
+};
+
+export { outputFetch } from './fetch/index.js';
+export { HTTPRequestCount } from './fetch/logger.js';
+export { createKyClient } from './ky/index.js';
+
+export { addRequestCost, HTTPRequestCost } from './cost.js';
+
+/** Re-export ky library for convenience. */
+export * as ky from 'ky';
+export * as undici from 'undici';

package/src/http/index.js

@@ -0,0 +1,9 @@
+export { outputFetch } from './fetch/index.js';
+export { HTTPRequestCount } from './fetch/logger.js';
+export { createKyClient } from './ky/index.js';
+
+export { addRequestCost, HTTPRequestCost } from './cost.js';
+
+/** Re-export ky library for convenience. */
+export * as ky from 'ky';
+export * as undici from 'undici';

package/src/http/ky/index.d.ts

@@ -0,0 +1,25 @@
+import type { KyInstance, Options } from 'ky';
+
+/**
+ * Creates a ky client.
+ *
+ * This client uses a custom fetch that introduces hooks to integrate with Output.ai tracing.
+ *
+ * @example
+ * ```ts
+ * import { createKyClient } from '@outputai/core/http';
+ *
+ * const client = createKyClient({
+ *   prefix: 'https://api.example.com',
+ *   timeout: 30000,
+ *   retry: { limit: 3 }
+ * });
+ *
+ * const response = await client.get('users/1');
+ * const data = await response.json();
+ * ```
+ *
+ * @param options - The ky options to extend the base client.
+ * @returns A ky instance extended with Output.ai tracing hooks.
+ */
+export declare function createKyClient( options?: Options ): KyInstance;

package/src/http/ky/index.js

@@ -0,0 +1,10 @@
+import ky from 'ky';
+import { outputFetch } from '../fetch/index.js';
+
+/**
+ * Creates a ky client that uses `outputFetch`.
+ *
+ * @param {import('ky').Options} options - The ky options to extend the base client.
+ * @returns {import('ky').KyInstance} A ky instance extended with Output.ai tracing hooks.
+ */
+export const createKyClient = ( options = {} ) => ky.create( { fetch: outputFetch, ...options } );

package/src/http/request_tag.js

@@ -0,0 +1,30 @@
+/**
+ * Symbol used to store request id in the response object.
+ */
+export const requestIdSymbol = Symbol( 'request_id' );
+
+/**
+ * Tag a response in place with its request id so downstream code (e.g.
+ * `addRequestCost`) can correlate. Stores the id under a private symbol AND
+ * patches `clone()` so the tag propagates to clones — ky clones the response
+ * before invoking `afterResponse` hooks, and undici headers are immutable on
+ * received responses, so a symbol re-attached inside `clone()` is the only
+ * path that survives.
+ *
+ * @param {Response} response
+ * @param {string} requestId
+ */
+export const addRequestIdToResponse = ( response, requestId ) => {
+  Object.defineProperty( response, requestIdSymbol, { value: requestId, enumerable: false, configurable: false, writable: false } );
+  const originalClone = response.clone.bind( response );
+  Object.defineProperty( response, 'clone', {
+    value: function clone() {
+      const cloned = originalClone();
+      addRequestIdToResponse( cloned, requestId );
+      return cloned;
+    },
+    enumerable: false,
+    configurable: true,
+    writable: true
+  } );
+};