libretto 0.4.4 → 0.5.1

package/dist/shared/llm/types.d.cts

@@ -1,67 +0,0 @@
-import z from 'zod';
-
-type MessageContentPart = {
-    type: "text";
-    text: string;
-} | {
-    type: "image";
-    image: string | Uint8Array;
-    mediaType?: string;
-};
-type Message = {
-    role: "user" | "assistant";
-    content: string | MessageContentPart[];
-};
-/**
- * Pluggable LLM client interface.
- *
- * Users provide their own implementation backed by any LLM provider
- * (OpenAI, Anthropic, etc.). Libretto uses this interface for AI extraction,
- * recovery agents, and error detection.
- *
- * **Error handling:** implementations should throw on failure rather than
- * returning sentinel values (e.g. `null` or `undefined`). Libretto relies
- * on exceptions to trigger retry/recovery logic.
- *
- * A ready-made adapter for the Vercel AI SDK is available via
- * {@link createLLMClientFromModel} in `libretto/llm`.
- */
-interface LLMClient {
-    /**
-     * Generate a structured object from a single text prompt.
-     *
-     * The underlying model **must** support structured / JSON output so that
-     * the response can be parsed and validated against the provided Zod schema.
-     *
-     * @param opts.prompt - The text prompt sent to the model.
-     * @param opts.schema - A Zod schema describing the expected response shape.
-     * @param opts.temperature - Sampling temperature (default chosen by implementation, typically 0).
-     * @returns The parsed object matching the schema.
-     * @throws On LLM or parsing failure.
-     */
-    generateObject<T extends z.ZodType>(opts: {
-        prompt: string;
-        schema: T;
-        temperature?: number;
-    }): Promise<z.output<T>>;
-    /**
-     * Generate a structured object from a conversation-style message array.
-     *
-     * Messages may contain **image content** (base64 data URIs via
-     * {@link MessageContentPart}), so the backing model must support
-     * vision / multimodal input when images are present.
-     *
-     * @param opts.messages - Ordered list of user/assistant messages, potentially multimodal.
-     * @param opts.schema - A Zod schema describing the expected response shape.
-     * @param opts.temperature - Sampling temperature (default chosen by implementation, typically 0).
-     * @returns The parsed object matching the schema.
-     * @throws On LLM or parsing failure.
-     */
-    generateObjectFromMessages<T extends z.ZodType>(opts: {
-        messages: Message[];
-        schema: T;
-        temperature?: number;
-    }): Promise<z.output<T>>;
-}
-
-export type { LLMClient, Message, MessageContentPart };

package/dist/shared/logger/index.cjs

@@ -1,37 +0,0 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var logger_exports = {};
-__export(logger_exports, {
-  Logger: () => import_logger.Logger,
-  createFileLogSink: () => import_sinks.createFileLogSink,
-  defaultLogger: () => import_logger.defaultLogger,
-  jsonlConsoleSink: () => import_sinks.jsonlConsoleSink,
-  prettyConsoleSink: () => import_sinks.prettyConsoleSink
-});
-module.exports = __toCommonJS(logger_exports);
-var import_logger = require("./logger.js");
-var import_sinks = require("./sinks.js");
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  Logger,
-  createFileLogSink,
-  defaultLogger,
-  jsonlConsoleSink,
-  prettyConsoleSink
-});

package/dist/shared/logger/index.d.cts

@@ -1,2 +0,0 @@
-export { LogOptions, Logger, LoggerApi, LoggerSink, MinimalLogger, defaultLogger } from './logger.cjs';
-export { createFileLogSink, jsonlConsoleSink, prettyConsoleSink } from './sinks.cjs';

package/dist/shared/logger/logger.cjs

@@ -1,232 +0,0 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var logger_exports = {};
-__export(logger_exports, {
-  Logger: () => Logger,
-  defaultLogger: () => defaultLogger
-});
-module.exports = __toCommonJS(logger_exports);
-function generateId() {
-  return Math.random().toString(36).substring(2, 15);
-}
-const defaultLogger = {
-  info(event, data) {
-    console.log(`[INFO] ${event}`, data ?? "");
-  },
-  warn(event, data) {
-    console.warn(`[WARN] ${event}`, data ?? "");
-  },
-  error(event, data) {
-    console.error(`[ERROR] ${event}`, data ?? "");
-  }
-};
-const sinkLifecycleState = /* @__PURE__ */ new WeakMap();
-function getSinkLifecycleState(sink) {
-  const existingState = sinkLifecycleState.get(sink);
-  if (existingState) {
-    return existingState;
-  }
-  const initialState = { closed: false };
-  sinkLifecycleState.set(sink, initialState);
-  return initialState;
-}
-function isSinkClosedOrClosing(sink) {
-  const state = sinkLifecycleState.get(sink);
-  return Boolean(state?.closed || state?.closing);
-}
-async function closeSinkOnce(sink) {
-  if (!sink.close) {
-    return;
-  }
-  const state = getSinkLifecycleState(sink);
-  if (state.closed) {
-    return;
-  }
-  if (state.closing) {
-    return state.closing;
-  }
-  state.closing = (async () => {
-    try {
-      await sink.close?.();
-    } catch {
-    } finally {
-      state.closed = true;
-      state.closing = void 0;
-    }
-  })();
-  return state.closing;
-}
-function isObject(value) {
-  return typeof value === "object" && value !== null;
-}
-function removeUndefined(data) {
-  if (typeof data === "object" && data !== null) {
-    return Object.fromEntries(
-      Object.entries(data).filter(([_, value]) => value !== void 0)
-    );
-  }
-  return data;
-}
-class Logger {
-  constructor(scopes = [], sinks = [], scopeData = {}) {
-    this.scopes = scopes;
-    this.sinks = sinks;
-    this.scopeData = scopeData;
-    this.prefix = scopes.join(".");
-  }
-  prefix;
-  entry(entry) {
-    this.sinks.forEach((sink) => {
-      if (isSinkClosedOrClosing(sink)) {
-        return;
-      }
-      sink.write({
-        id: generateId(),
-        scope: this.prefix,
-        level: entry.level,
-        event: entry.event,
-        data: removeUndefined({ ...this.scopeData, ...entry.data }),
-        options: entry.options
-      });
-    });
-  }
-  log(event, data, options) {
-    this.entry({ level: "log", event, data, options });
-  }
-  error(event, dataOrError, options) {
-    const data = dataOrError instanceof Error ? {
-      error: {
-        type: dataOrError.constructor.name,
-        message: dataOrError.message,
-        stack: dataOrError.stack || null
-      }
-    } : isObject(dataOrError) && dataOrError.error instanceof Error ? {
-      ...dataOrError,
-      error: {
-        type: dataOrError.error.constructor.name,
-        message: dataOrError.error.message,
-        stack: dataOrError.error.stack || null
-      }
-    } : isObject(dataOrError) ? dataOrError : dataOrError !== void 0 ? { error: dataOrError } : void 0;
-    this.entry({
-      level: "error",
-      event,
-      data,
-      options
-    });
-    if (dataOrError instanceof Error) {
-      return dataOrError;
-    }
-    if (isObject(dataOrError) && dataOrError.error instanceof Error) {
-      return dataOrError.error;
-    }
-    let message = event;
-    if (data !== void 0) {
-      try {
-        message += "\n" + JSON.stringify(data, void 0, 2);
-      } catch {
-        message += "\n[Unserializable error data]";
-      }
-    }
-    return new Error(message);
-  }
-  warn(event, dataOrError, options) {
-    const data = dataOrError instanceof Error ? {
-      error: {
-        type: dataOrError.constructor.name,
-        message: dataOrError.message,
-        stack: dataOrError.stack || null
-      }
-    } : isObject(dataOrError) && dataOrError.error instanceof Error ? {
-      ...dataOrError,
-      error: {
-        type: dataOrError.error.constructor.name,
-        message: dataOrError.error.message,
-        stack: dataOrError.error.stack || null
-      }
-    } : isObject(dataOrError) ? dataOrError : dataOrError !== void 0 ? { error: dataOrError } : void 0;
-    this.entry({
-      level: "warn",
-      event,
-      data,
-      options
-    });
-  }
-  info(event, dataOrError, options) {
-    const data = dataOrError instanceof Error ? {
-      error: {
-        type: dataOrError.constructor.name,
-        message: dataOrError.message,
-        stack: dataOrError.stack || null
-      }
-    } : isObject(dataOrError) && dataOrError.error instanceof Error ? {
-      ...dataOrError,
-      error: {
-        type: dataOrError.error.constructor.name,
-        message: dataOrError.error.message,
-        stack: dataOrError.error.stack || null
-      }
-    } : isObject(dataOrError) ? dataOrError : dataOrError !== void 0 ? { error: dataOrError } : void 0;
-    this.entry({
-      level: "info",
-      event,
-      data,
-      options
-    });
-  }
-  withScope(scope, context = {}) {
-    return new Logger([...this.scopes, scope], this.sinks, {
-      ...this.scopeData,
-      ...context
-    });
-  }
-  withContext(context) {
-    return new Logger(this.scopes, this.sinks, {
-      ...this.scopeData,
-      ...context
-    });
-  }
-  withSink(sink) {
-    return new Logger(this.scopes, [...this.sinks, sink]);
-  }
-  async flush() {
-    for (let i = this.sinks.length - 1; i >= 0; i--) {
-      const sink = this.sinks[i];
-      if (!sink) continue;
-      if (isSinkClosedOrClosing(sink)) continue;
-      try {
-        await sink.flush?.();
-      } catch {
-      }
-    }
-  }
-  async close() {
-    await this.flush();
-    for (let i = this.sinks.length - 1; i >= 0; i--) {
-      const sink = this.sinks[i];
-      if (!sink) continue;
-      await closeSinkOnce(sink);
-    }
-  }
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  Logger,
-  defaultLogger
-});

package/dist/shared/logger/logger.d.cts

@@ -1,86 +0,0 @@
-type LogOptions = {
-    timestamp?: Date;
-};
-/**
- * Minimal logger interface accepted by public-facing runtime functions.
- * Any logger with info/warn/error methods satisfies this — no need to
- * implement withScope, withContext, flush, etc.
- */
-type MinimalLogger = {
-    info: (event: string, data?: any) => void;
-    warn: (event: string, data?: any) => void;
-    error: (event: string, data?: any) => any;
-};
-/** Default console logger used when callers omit the logger option. */
-declare const defaultLogger: MinimalLogger;
-type LoggerApi = {
-    log: (event: string, data?: Record<string, any>, options?: LogOptions) => void;
-    /**
-     * Logs an error and returns an Error object that can be thrown
-     *
-     * either pass in an Error directly as data or as { error: Error, ...other_data }
-     */
-    error: (event: string, data?: Error | ({
-        error: Error;
-    } & Record<string, any>) | unknown, options?: LogOptions) => Error;
-    warn: (event: string, data?: Error | ({
-        error: Error;
-    } & Record<string, any>) | unknown, options?: LogOptions) => void;
-    info: (event: string, data?: Error | ({
-        error: Error;
-    } & Record<string, any>) | unknown, options?: LogOptions) => void;
-    /**
-     * Context passed in will be attached to all entries in this scope.
-     */
-    withScope: (scope: string, context?: Record<string, any>) => LoggerApi;
-    /**
-     * Context passed in will be attached to all entries.
-     */
-    withContext: (context: Record<string, any>) => LoggerApi;
-    /**
-     * Flushes all sinks in reverse order (most recently added first).
-     */
-    flush: () => Promise<void>;
-};
-type LoggerSink = {
-    write: (args: {
-        id: string;
-        scope: string;
-        level: "log" | "error" | "warn" | "info";
-        event: string;
-        data: Record<string, any>;
-        options?: LogOptions;
-    }) => void;
-    flush?: () => Promise<void>;
-    close?: () => Promise<void>;
-};
-declare class Logger implements LoggerApi {
-    private readonly scopes;
-    private readonly sinks;
-    private readonly scopeData;
-    private readonly prefix;
-    constructor(scopes?: string[], sinks?: LoggerSink[], scopeData?: Record<string, any>);
-    entry(entry: {
-        level: "log" | "error" | "warn" | "info";
-        event: string;
-        data?: Record<string, any>;
-        options?: LogOptions;
-    }): void;
-    log(event: string, data?: Record<string, any>, options?: LogOptions): void;
-    error(event: string, dataOrError?: Error | ({
-        error: Error;
-    } & Record<string, any>) | unknown, options?: LogOptions): Error;
-    warn(event: string, dataOrError?: Error | ({
-        error: Error;
-    } & Record<string, any>) | unknown, options?: LogOptions): void;
-    info(event: string, dataOrError?: Error | ({
-        error: Error;
-    } & Record<string, any>) | unknown, options?: LogOptions): void;
-    withScope(scope: string, context?: Record<string, any>): LoggerApi;
-    withContext(context: Record<string, any>): LoggerApi;
-    withSink(sink: LoggerSink): Logger;
-    flush(): Promise<void>;
-    close(): Promise<void>;
-}
-
-export { type LogOptions, Logger, type LoggerApi, type LoggerSink, type MinimalLogger, defaultLogger };

package/dist/shared/logger/sinks.cjs

@@ -1,160 +0,0 @@
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var sinks_exports = {};
-__export(sinks_exports, {
-  createFileLogSink: () => createFileLogSink,
-  jsonlConsoleSink: () => jsonlConsoleSink,
-  prettyConsoleSink: () => prettyConsoleSink
-});
-module.exports = __toCommonJS(sinks_exports);
-var fs = __toESM(require("node:fs"), 1);
-var path = __toESM(require("node:path"), 1);
-function createFileLogSink({
-  filePath
-}) {
-  fs.mkdirSync(path.dirname(filePath), { recursive: true });
-  const writeStream = fs.createWriteStream(filePath, { flags: "a" });
-  return {
-    write: ({ id, scope, level, event, data, options }) => {
-      if (writeStream.destroyed || writeStream.writableEnded) {
-        return;
-      }
-      const timestamp = options?.timestamp || /* @__PURE__ */ new Date();
-      const logEntry = {
-        timestamp: timestamp.toISOString(),
-        id,
-        level,
-        scope,
-        event,
-        data
-      };
-      const jsonLine = JSON.stringify(logEntry) + "\n";
-      try {
-        writeStream.write(jsonLine, (error) => {
-          if (error) {
-            console.error("Failed to write to log file:", error);
-            console[level]({ id, scope, event, data, timestamp });
-          }
-        });
-      } catch (error) {
-        console.error("Failed to write to log file:", error);
-        console[level]({ id, scope, event, data, timestamp });
-      }
-    },
-    flush: () => new Promise((resolve, reject) => {
-      if (!writeStream.writable || writeStream.writableEnded || writeStream.destroyed) {
-        resolve();
-        return;
-      }
-      writeStream.write("", (error) => {
-        if (error) {
-          reject(error);
-        } else {
-          resolve();
-        }
-      });
-    }),
-    close: () => new Promise((resolve) => {
-      if (writeStream.destroyed || writeStream.closed) {
-        resolve();
-        return;
-      }
-      let settled = false;
-      const done = () => {
-        if (settled) return;
-        settled = true;
-        resolve();
-      };
-      writeStream.once("finish", done);
-      writeStream.once("close", done);
-      writeStream.once("error", done);
-      try {
-        writeStream.end();
-      } catch {
-        done();
-      }
-    })
-  };
-}
-const colors = {
-  reset: "\x1B[0m",
-  gray: "\x1B[90m",
-  red: "\x1B[31m",
-  yellow: "\x1B[33m",
-  blue: "\x1B[34m",
-  cyan: "\x1B[36m"
-};
-function formatTimestamp(date) {
-  return date.toISOString().replace("T", " ").replace("Z", "");
-}
-const prettyConsoleSink = {
-  write: ({ scope, level, event, data, options }) => {
-    const timestamp = `${colors.gray}${formatTimestamp(options?.timestamp || /* @__PURE__ */ new Date())}${colors.reset}`;
-    const levelColor = level === "error" ? colors.red : level === "warn" ? colors.yellow : colors.blue;
-    const coloredScope = scope ? `${colors.cyan}[${scope}]${colors.reset}` : "";
-    const logPrefix = `${timestamp} ${levelColor}${level.toUpperCase()}${colors.reset} ${coloredScope} ${event}`;
-    if (level === "error" && data.error) {
-      const { error, ...otherData } = data;
-      console.error(logPrefix);
-      if (error.stack) {
-        console.error(`  ${error.stack}`);
-      } else if (error.type && error.message) {
-        console.error(`  ${error.type}: ${error.message}`);
-      }
-      if (Object.keys(otherData).length > 0) {
-        console.error(JSON.stringify(otherData, null, 2));
-      }
-    } else {
-      console[level](logPrefix);
-      if (Object.keys(data).length > 0) {
-        console[level](JSON.stringify(data, null, 2));
-      }
-    }
-  }
-};
-const jsonlConsoleSink = {
-  write: ({ id, scope, level, event, data, options }) => {
-    const timestamp = options?.timestamp || /* @__PURE__ */ new Date();
-    const logEntry = {
-      timestamp: timestamp.toISOString(),
-      id,
-      level,
-      scope: scope || void 0,
-      event,
-      data
-    };
-    console.log(JSON.stringify(logEntry));
-  }
-};
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  createFileLogSink,
-  jsonlConsoleSink,
-  prettyConsoleSink
-});

package/dist/shared/logger/sinks.d.cts

@@ -1,9 +0,0 @@
-import { LoggerSink } from './logger.cjs';
-
-declare function createFileLogSink({ filePath, }: {
-    filePath: string;
-}): LoggerSink;
-declare const prettyConsoleSink: LoggerSink;
-declare const jsonlConsoleSink: LoggerSink;
-
-export { createFileLogSink, jsonlConsoleSink, prettyConsoleSink };