@outputai/core 0.8.1-next.e92f632.0 → 0.8.2-dev.e78f6b4.0

package/src/activity_integration/tracing.d.ts

@@ -1,40 +0,0 @@
-import type { Attribute } from '#trace_attribute';
-
-export { Attribute } from '#trace_attribute';
-/**
- * Creates a new event.
- *
- * @param args
- * @param args.id - A unique id for the Event.
- * @param args.kind - The kind of Event, like HTTP, DiskWrite, DBOp, etc.
- * @param args.name - The human-friendly name of the Event: query, request, create.
- * @param args.details - Arbitrary data to add to this event, it will be used as the "input" field.
- */
-export declare function addEventStart( args: { id: string; kind: string; name: string; details: unknown } ): void;
-
-/**
- * Concludes an event.
- *
- * @param args
- * @param args.id - The id of the event to conclude.
- * @param args.details - Arbitrary data to add to this event, it will be used as the "output" field.
- */
-export declare function addEventEnd( args: { id: string; details: unknown } ): void;
-
-/**
- * Concludes an event with an error.
- *
- * @param args
- * @param args.id - The id of the event to conclude.
- * @param args.details - Arbitrary data to add to this event, it will be used as the "error" field.
- */
-export declare function addEventError( args: { id: string; details: unknown } ): void;
-
-/**
- * Adds an attribute to an event.
- *
- * @param args
- * @param args.eventId - The id of the event to attach the attribute to.
- * @param args.attribute - The attribute to attach to the event.
- */
-export declare function addEventAttribute( args: { eventId: string; attribute: Attribute.Instance } ): void;

package/src/activity_integration/tracing.js

@@ -1,48 +0,0 @@
-import { addEventActionWithContext, EventAction } from '#tracing';
-
-export { Attribute } from '#trace_attribute';
-
-/**
- * Creates a new event.
- *
- * @param {object} args
- * @param {string} args.id - A unique id for the Event.
- * @param {string} args.kind - The kind of Event, like HTTP, DiskWrite, DBOp, etc.
- * @param {string} args.name - The human-friendly name of the Event: query, request, create.
- * @param {object} args.details - Arbitrary data to add to this event, it will be used as the "input" field.
- * @returns {void}
- */
-export const addEventStart = ( { id, kind, name, details } ) =>
-  addEventActionWithContext( EventAction.START, { kind, name, details, id } );
-
-/**
- * Concludes an event.
- *
- * @param {object} args
- * @param {string} args.id - The id of the event to conclude.
- * @param {object} args.details - Arbitrary data to add to this event, it will be used as the "output" field.
- * @returns {void}
- */
-export const addEventEnd = ( { id, details } ) => addEventActionWithContext( EventAction.END, { id, details } );
-
-/**
- * Concludes an event with an error.
- *
- * @param {object} args
- * @param {string} args.id - The id of the event to conclude.
- * @param {object} args.details - Arbitrary data to add to this event, it will be used as the "error" field.
- * @returns {void}
- */
-export const addEventError = ( { id, details } ) => addEventActionWithContext( EventAction.ERROR, { id, details } );
-
-/**
- * Adds an attribute to an event.
- *
- * @param {object} args
- * @param {string} args.eventId - The id of the event to attach the attribute to.
- * @param {string} args.name - The attribute name
- * @param {unknown} args.value - The attribute value
- * @returns {void}
- */
-export const addEventAttribute = ( { eventId, attribute } ) =>
-  addEventActionWithContext( EventAction.ADD_ATTR, { id: eventId, details: attribute } );

package/src/utils/index.d.ts

@@ -1,180 +0,0 @@
-/**
- * > [!WARNING]
- * > **Internal use only.** Not part of the public API; may change without notice.
- *
- * @packageDocumentation
- */
-
-/**
- * Return the first immediate directory of the file invoking the code that called this function.
- *
- * Excludes `@outputai/core`, node, and other internal paths.
- */
-export function resolveInvocationDir(): string;
-
-/**
- * Node safe clone implementation that doesn't use global structuredClone().
- *
- * Returns a cloned version of the object.
- *
- * Only clones static properties. Getters become static properties.
- *
- * @param object
- */
-export function clone( object: object ): object;
-
-/**
- * Receives an error as argument and throws it.
- *
- * @param error
- * @throws {Error}
- */
-export function throws( error: Error ): void;
-
-/**
- * Attach given value to an object with the METADATA_ACCESS_SYMBOL symbol as key.
- *
- * @param target
- * @param value
- * @returns
- */
-export function setMetadata( target: object, value: object ): void;
-
-/**
- * Read metadata previously attached via setMetadata.
- *
- * @param target - The function or object to read metadata from.
- * @returns The metadata object, or null if none is attached.
- */
-export function getMetadata( target: Function ): { name: string; description?: string; type?: string } | null;
-
-/** Represents a {Response} serialized to plain object  */
-export type SerializedFetchResponse = {
-  /** The response url */
-  url: string,
-
-  /** The response status code */
-  status: number,
-
-  /** The response status text */
-  statusText: string,
-
-  /** Flag indicating if the request succeeded */
-  ok: boolean,
-
-  /** Object with response headers */
-  headers: Record<string, string>,
-
-  /** Response body, either JSON, text or arrayBuffer converter to base64 */
-  body: object | string
-};
-
-/**
- * Consumes an HTTP `Response` and serializes it to a plain object.
- *
- * @param response - The response to serialize.
- * @returns SerializedFetchResponse
- */
-export function serializeFetchResponse( response: Response ): SerializedFetchResponse;
-
-export type SerializedBodyAndContentType = {
-  /** The body as a string when possible; otherwise the original value */
-  body: string | unknown,
-  /** The inferred `Content-Type` header value, if any */
-  contentType: string | undefined
-};
-
-/**
- * Serializes a payload for use as a fetch POST body and infers its `Content-Type`.
- *
- * @param body - The payload to serialize.
- * @returns The serialized body and inferred `Content-Type`.
- */
-export function serializeBodyAndInferContentType( body: unknown ): SerializedBodyAndContentType;
-
-/**
- * Returns true if the value is a plain object:
- * - `{}`
- * - `new Object()`
- * - `Object.create(null)`
- *
- * @param object - The value to check.
- * @returns Whether the value is a plain object.
- */
-export function isPlainObject( object: unknown ): boolean;
-
-/**
- * Returns a copy of an array with its content shuffled.
- *
- * @param arr - The array to shuffle
- * @returns A shuffled array copy
- */
-export function shuffleArray( arr: unknown[] ): unknown[];
-
-/**
- * Creates a new object by merging object `b` onto object `a`, biased toward `b`:
- * - Fields in `b` overwrite fields in `a`.
- * - Fields in `b` that don't exist in `a` are created.
- * - Fields in `a` that don't exist in `b` are left unchanged.
- *
- * @param a - The base object.
- * @param b - The overriding object.
- * @throws {Error} If either `a` or `b` is not a plain object.
- * @returns A new merged object.
- */
-export function deepMerge( a: object, b: object | null | undefined ): object;
-
-/**
- * Creates a new object by merging object `b` onto object `a`, biased toward `b`:
- * - Fields in `b` that don't exist in `a` are created.
- * - Fields in `a` that don't exist in `b` are left unchanged.
- * - Fields in `a` and `b` are passed as arguments to the resolve function (a,b) and its return assigns the new value.
- *
- * @param a - The base object.
- * @param b - The overriding object.
- * @param resolver - The resolver function.
- * @throws {Error} If either `a` or `b` is not a plain object.
- * @returns A new merged object.
- */
-export function deepMergeWithResolver( a: object, b: object | null | undefined, resolver: function ): object;
-
-/**
- * Shortens a UUID to a url-safe base64-like string (custom 64-char alphabet).
- * Temporal-friendly: no Buffer or crypto; safe to use inside workflows.
- *
- * @param uuid - Standard UUID (e.g. `xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx`).
- * @returns Short string using A–Z, a–z, 0–9, `_`, `-` (typically 21–22 chars).
- */
-export function toUrlSafeBase64( uuid: string ): string;
-
-/**
- * Similar to native Promise.allSettled, but rejects with `{ isTimeout: true }`
- * if the execution exceeds the given timeout.
- *
- * @param promises - Values or promises to wait for.
- * @param timeoutMs - Maximum wait time in milliseconds.
- * @returns Native Promise.allSettled-style results.
- */
-export function allSettledWithTimeout<T>(
-  promises: Array<T | PromiseLike<T>>,
-  timeoutMs: number
-): Promise<PromiseSettledResult<Awaited<T>>[]>;
-
-/**
- * Promise wrapper that can be resolved externally.
- */
-export class CancellablePromise {
-  /** The internal promise */
-  readonly promise: Promise<void>;
-  /** Whether the promise is already resolved or not */
-  readonly completed: boolean;
-  /** Resolves the promise */
-  complete(): void;
-}
-
-/**
- * Returns a function that invokes the wrapped function once.
- */
-export function runOnce<Args extends unknown[], Return>(
-  fn: ( ...args: Args ) => Return
-): ( ...args: Args ) => Return;

package/src/utils/index.js

@@ -1,2 +0,0 @@
-export { default as resolveInvocationDir } from './resolve_invocation_dir.js';
-export * from './utils.js';

package/src/utils/resolve_invocation_dir.js

@@ -1,34 +0,0 @@
-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/llm/',
-  '/@outputai/evals/',
-  '/sdk/core/',
-  '/sdk/llm/',
-  '/sdk/evals/',
-  'node:internal/',
-  'evalmachine.',
-  'webpack/bootstrap'
-];
-
-/**
- * Return the directory of the file invoking the code that called this function
- * Excludes some internal paths and the sdk itself
- */
-export default ( 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/utils/utils.js

@@ -1,334 +0,0 @@
-import { METADATA_ACCESS_SYMBOL } from '#consts';
-
-/**
- * Node safe clone implementation that doesn't use global structuredClone()
- * @param {object} v
- * @returns {object}
- */
-export const clone = v => {
-  try {
-    return JSON.parse( JSON.stringify( v ) );
-  } catch {
-    return v;
-  }
-};
-
-/**
- * Detect a JS plain object.
- *
- * @param {unknown} v
- * @returns {boolean}
- */
-export const isPlainObject = v =>
-  typeof v === 'object' &&
-    !Array.isArray( v ) &&
-    v !== null &&
-    [ Object.prototype, null ].includes( Object.getPrototypeOf( v ) );
-
-/**
- * Throw given error
- * @param {Error} e
- * @throws {e}
- */
-export const throws = e => {
-  throw e;
-};
-
-/**
- * Add metadata "values" property to a given object
- * @param {object} target
- * @param {object} values
- * @returns
- */
-export const setMetadata = ( target, values ) =>
-  Object.defineProperty( target, METADATA_ACCESS_SYMBOL, { value: values, writable: false, enumerable: false, configurable: false } );
-
-/**
- * Read metadata previously attached via setMetadata
- * @param {Function} target
- * @returns {object|null}
- */
-export const getMetadata = target => target[METADATA_ACCESS_SYMBOL] ?? null;
-
-/**
- * Returns true if string value is stringbool and true
- * @param {string} v
- * @returns
- */
-export const isStringboolTrue = v => [ '1', 'true', 'on' ].includes( v );
-
-/**
- * Consume Fetch's HTTP Response and return a serialized version of it;
- *
- * @param {Response} response
- * @returns {object} Serialized response
- */
-export const serializeFetchResponse = async response => {
-  const headers = Object.fromEntries( response.headers );
-  const contentType = headers['content-type'] || '';
-
-  const body = await ( async () => {
-    if ( contentType.includes( 'application/json' ) ) {
-      return response.json();
-    }
-    if ( contentType.startsWith( 'text/' ) ) {
-      return response.text();
-    }
-    return response.arrayBuffer().then( buf => Buffer.from( buf ).toString( 'base64' ) );
-  } )();
-
-  return {
-    url: response.url,
-    status: response.status,
-    statusText: response.statusText,
-    ok: response.ok,
-    headers,
-    body
-  };
-};
-
-/**
- * Duck-typing to detect a Node Readable (Stream) without importing anything
- *
- * @param {unknown} v
- * @returns {boolean}
- */
-const isReadable = v =>
-  typeof v === 'object' &&
-  typeof v?.read === 'function' &&
-  typeof v?.on === 'function' &&
-  typeof v?.pipe === 'function' &&
-  v?.readable !== false;
-
-/**
- * Based on the type of a payload, serialized it to be send as the body of a fetch POST request and also infer its Content Type.
- *
- * Non serializable types versus Content-Type reference (for Node)
- *
- * |Type|Is self-describing)|Inferred type by fetch|Defined mime type|
- * |-|-|-|-}
- * |Blob|yes|`blob.type`||
- * |File|yes|`file.type`||
- * |FormData|yes|"multipart/form-data; boundary=..."||
- * |URLSearchParams|yes|"application/x-www-form-urlencoded;charset=UTF-8"||
- * |ArrayBuffer|no||"application/octet-stream"|
- * |TypedArray (Uint8Array,Uint16Array)||"application/octet-stream"||
- * |DataView|no||"application/octet-stream"|
- * |ReadableStream, Readable, AsyncIterator|no||Can't, because stream must be read|
- *
- * If payload is none of the above types, test it:
- * If the it is an object, serialize using JSON.stringify and set content-type to `application/json`;
- * Else, it is a JS primitive, serialize using JSON.stringify and set content-type to `text/plain`;
- *
- * This implementation is overkill for temporal workflows since the only types available there will be:
- * - URLSearchParams
- * - ArrayBuffer
- * - TypedArrays
- * - DataView
- * - asyncGenerator
- * The others are non deterministic and are not available at runtime, but this function was build to be flexible
- *
- * @see {@link https://fetch.spec.whatwg.org/#bodyinit}
- * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API/Using_Fetch}
- *
- * @param {unknown} payload
- * @returns {object} An object with the serialized body and inferred content-type
- */
-export const serializeBodyAndInferContentType = payload => {
-  const dataTypes = [ Blob, File, URLSearchParams, FormData ];
-
-  // empty body
-  if ( [ null, undefined ].includes( payload ) ) {
-    return { body: undefined, contentType: undefined };
-  }
-
-  // Buffer types, covers ArrayBuffer, TypedArrays and DataView
-  if ( payload instanceof ArrayBuffer || ArrayBuffer.isView( payload ) ) {
-    return { body: payload, contentType: 'application/octet-stream' };
-  }
-
-  // These data types auto assigned mime types
-  if ( dataTypes.some( t => payload instanceof t ) ) {
-    return { body: payload, contentType: undefined };
-  }
-
-  // ReadableStream, Readable and Async Iterator mimes cant be determined without reading it
-  if ( payload instanceof ReadableStream || typeof payload[Symbol.asyncIterator] === 'function' || isReadable( payload ) ) {
-    return { body: payload, contentType: undefined };
-  }
-
-  if ( typeof payload === 'object' ) {
-    return { body: JSON.stringify( payload ), contentType: 'application/json; charset=UTF-8' };
-  }
-
-  return { body: String( payload ), contentType: 'text/plain; charset=UTF-8' };
-};
-
-/**
- * Receives an array and returns a copy of it with the elements shuffled
- *
- * @param {array} arr
- * @returns {array}
- */
-export const shuffleArray = arr => arr
-  .map( v => ( { v, sort: Math.random() } ) )
-  .sort( ( a, b ) => a.sort - b.sort )
-  .map( ( { v } ) => v );
-
-/**
- * Creates a new object merging object "b" onto object "a", using a resolver function to define the value to keep.
- * - Object "b" fields that also exists on "a" will have their value defined by the "resolver" function
- * - Object "b" fields that don't exist on object "a" will be added;
- * - Object "a" fields that don't exist on object "b" will be preserved;
- *
- * If "b" isn't an object, a new object equal to "a" is returned
- *
- * @param {object} a - The base object
- * @param {object} b - The target object
- * @param {function} resolver - A function that return the value to be kept. First argument is value a, second is value b
- * @returns {object} A new object
- */
-export const deepMergeWithResolver = ( a, b, resolver ) => {
-  if ( !isPlainObject( a ) ) {
-    throw new Error( 'Parameter "a" is not an object.' );
-  }
-  if ( !isPlainObject( b ) ) {
-    return clone( a );
-  }
-  return Object.entries( b ).reduce( ( obj, [ k, v ] ) =>
-    Object.assign( obj, {
-      [k]: ( () => {
-        if ( isPlainObject( v ) && isPlainObject( a[k] ) ) {
-          return deepMergeWithResolver( a[k], v, resolver );
-        }
-        if ( Object.hasOwn( a, k ) ) {
-          return resolver( a[k], v );
-        }
-        return v;
-      } )()
-    } )
-  , clone( a ) );
-};
-
-/**
- * Creates a new object merging object "b" onto object "a" biased to "b":
- * - Object "b" will overwrite fields on object "a";
- * - Object "b" fields that don't exist on object "a" will be added;
- * - Object "a" fields that don't exist on object "b" will be preserved;
- *
- * If "b" isn't an object, a new object equal to "a" is returned
- *
- * @param {object} a - The base object
- * @param {object} b - The target object
- * @returns {object} A new object
- */
-export const deepMerge = ( a, b ) => deepMergeWithResolver( a, b, ( _, b ) => b );
-
-/**
- * Shortens a UUID by re-encoding it to base62.
- *
- * This is a Temporal friendly, without crypto or Buffer.
- * @param {string} uuid
- * @returns {string}
- */
-export const toUrlSafeBase64 = uuid => {
-  const alphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_-';
-  const alphabetLen = alphabet.length;
-  const base = BigInt( alphabetLen );
-  const hex = uuid.replace( /-/g, '' );
-
-  const toDigits = n => n <= 0n ? [] : toDigits( n / base ).concat( alphabet[Number( n % base )] );
-  return toDigits( BigInt( '0x' + hex ) ).join( '' );
-};
-
-/**
- * Similar to native Promise.allSettled but throws an Error if the execution exceeds a given time.
- *
- * The error thrown will have attribute `.isTimeout` as `true`.
- *
- * @template T
- * @param {Array<T | PromiseLike<T>>} promises
- * @param {number} timeoutMs
- * @returns {Promise<PromiseSettledResult<Awaited<T>>[]>}
- * @throws {Error & { isTimeout: true }}
- */
-export const allSettledWithTimeout = ( () => {
-  class TimeoutError extends Error {
-    isTimeout = true;
-    constructor() {
-      super( 'Timed out before completing all promises' );
-    }
-  }
-
-  return async ( promises, timeoutMs ) => {
-    if ( promises.length === 0 ) {
-      return [];
-    }
-
-    const state = { timeoutMonitor: null };
-
-    try {
-      return await Promise.race( [
-        Promise.allSettled( promises ),
-        new Promise( ( _, reject ) => {
-          state.timeoutMonitor = setTimeout( () => reject( new TimeoutError() ), timeoutMs );
-        } )
-      ] );
-    } finally {
-      clearTimeout( state.timeoutMonitor );
-    }
-  };
-} )();
-
-/**
- * Builds a promise that can be resolved from the outside.
- */
-export class CancellablePromise {
-  #promise = null;
-  #complete = null;
-  #completed = false;
-
-  constructor() {
-    this.#promise = new Promise( resolve => {
-      this.#complete = () => {
-        resolve();
-        this.#completed = true;
-      };
-    } );
-  }
-  /** Retrieves the promise */
-  get promise() {
-    return this.#promise;
-  }
-  /** Returns whether the promise is resolved or not */
-  get completed() {
-    return this.#completed;
-  }
-  /** Resolves the promise */
-  complete() {
-    this.#complete();
-  }
-};
-
-/**
- * Returns a function that invokes the fn argument when called once, further calls do nothing.
- * @param {Function} fn
- * @returns {Function}
- */
-export const runOnce = fn => {
-  const state = { executed: false, result: undefined };
-  return ( ...args ) => {
-    if ( !state.executed ) {
-      state.executed = true;
-      return state.result = fn( ...args );
-    }
-    return state.result;
-  };
-};
-
-/**
- * Escape regexp characters in a string
- * @param {*} value
- * @returns
- */
-export const rxEscape = v => v.replace( /[.*+?^${}()|[\]\\]/g, '\\$&' );