@jaypie/llm 1.1.6 → 1.1.8

package/dist/types/LlmProvider.interface.d.ts

@@ -1,8 +1,100 @@
-import { JsonObject, NaturalSchema } from "@jaypie/types";
+import { AnyValue, JsonObject, JsonReturn, NaturalMap, NaturalSchema } from "@jaypie/types";
 import { z } from "zod";
 import { LlmTool } from "./LlmTool.interface.js";
+export declare enum LlmMessageRole {
+    Assistant = "assistant",
+    Developer = "developer",
+    System = "system",
+    User = "user"
+}
+export declare enum LlmMessageType {
+    FunctionCall = "function_call",
+    FunctionCallOutput = "function_call_output",
+    InputFile = "input_file",
+    InputImage = "input_image",
+    InputText = "input_text",
+    ItemReference = "item_reference",
+    Message = "message",
+    OutputText = "output_text",
+    Refusal = "refusal"
+}
+export declare enum LlmResponseStatus {
+    Completed = "completed",
+    Incomplete = "incomplete",
+    InProgress = "in_progress"
+}
+interface LlmError {
+    detail?: string;
+    status: number | string;
+    title: string;
+}
+interface LlmInputContentFile {
+    type: LlmMessageType.InputFile;
+    file_data: File;
+    file_id?: string;
+    filename?: string;
+}
+interface LlmInputContentImage {
+    type: LlmMessageType.InputImage;
+    detail: File;
+    file_id?: string;
+    image_url?: string;
+}
+interface LlmInputContentText {
+    type: LlmMessageType.InputText;
+    text: string;
+}
+type LlmInputContent = LlmInputContentFile | LlmInputContentImage | LlmInputContentText;
+/**
+ * Represents the "Input message object" in the "input item list"
+ * from [OpenAI Responses API](https://platform.openai.com/docs/api-reference/responses/create)
+ */
+export interface LlmInputMessage {
+    content: string | Array<LlmInputContent>;
+    role: LlmMessageRole;
+    type: LlmMessageType.Message;
+}
+export interface LlmOutputContentText {
+    annotations?: AnyValue[];
+    text: string;
+    type: LlmMessageType.OutputText;
+}
+interface LlmOutputRefusal {
+    refusal: string;
+    type: LlmMessageType.Refusal;
+}
+type LlmOutputContent = LlmOutputContentText | LlmOutputRefusal;
+export interface LlmOutputMessage {
+    content: Array<LlmOutputContent>;
+    id?: string;
+    role: LlmMessageRole.Assistant;
+    status: LlmResponseStatus;
+    type: LlmMessageType.Message;
+}
+type LlmOutputItem = LlmToolCall | LlmToolResult | LlmOutputMessage;
+type LlmOutput = LlmOutputItem[];
+export interface LlmToolCall {
+    arguments: string;
+    call_id: string;
+    id: string;
+    name: string;
+    type: LlmMessageType.FunctionCall;
+    status: LlmResponseStatus;
+}
+export interface LlmToolResult {
+    call_id: string;
+    output: string;
+    status?: LlmResponseStatus;
+    type: LlmMessageType.FunctionCallOutput;
+}
+interface LlmItemReference {
+    type: LlmMessageType.ItemReference;
+    id: string;
+}
+export type LlmHistoryItem = LlmInputMessage | LlmItemReference | LlmOutputItem | LlmToolResult;
+export type LlmHistory = LlmHistoryItem[];
 export interface LlmMessageOptions {
-    data?: Record<string, string>;
+    data?: NaturalMap;
     model?: string;
     placeholders?: {
         message?: boolean;
@@ -12,16 +104,19 @@ export interface LlmMessageOptions {
     system?: string;
 }
 export interface LlmOperateOptions {
-    data?: Record<string, string>;
+    data?: NaturalMap;
     explain?: boolean;
     format?: JsonObject | NaturalSchema | z.ZodType;
+    history?: LlmHistory;
     instructions?: string;
     model?: string;
     placeholders?: {
         input?: boolean;
         instructions?: boolean;
+        system?: boolean;
     };
-    providerOptions?: Record<string, unknown>;
+    providerOptions?: JsonObject;
+    system?: string;
     tools?: LlmTool[];
     turns?: boolean | number;
     user?: string;
@@ -30,7 +125,23 @@ export interface LlmOptions {
     apiKey?: string;
     model?: string;
 }
+interface LlmUsage {
+    input: number;
+    output: number;
+    reasoning: number;
+    total: number;
+}
+export interface LlmOperateResponse {
+    content?: string;
+    error?: LlmError;
+    history: LlmHistory;
+    output: LlmOutput;
+    responses: JsonReturn[];
+    status: LlmResponseStatus;
+    usage: LlmUsage;
+}
 export interface LlmProvider {
-    operate?(input: string, options?: LlmOperateOptions): Promise<unknown>;
+    operate?(input: string | LlmHistory | LlmInputMessage, options?: LlmOperateOptions): Promise<LlmOperateResponse>;
     send(message: string, options?: LlmMessageOptions): Promise<string | JsonObject>;
 }
+export {};

package/dist/types/LlmTool.interface.d.ts

@@ -1,8 +1,8 @@
-import { JsonObject } from "@jaypie/types";
+import { AnyValue, JsonObject } from "@jaypie/types";
 export interface LlmTool {
     description: string;
     name: string;
     parameters: JsonObject;
     type: "function" | string;
-    call: (...args: any[]) => Promise<any> | any;
+    call: (args?: JsonObject) => Promise<AnyValue> | AnyValue;
 }

package/dist/util/formatOperateInput.d.ts

@@ -0,0 +1,24 @@
+import { LlmHistory, LlmInputMessage, LlmMessageRole } from "../types/LlmProvider.interface.js";
+import { NaturalMap } from "@jaypie/types";
+/**
+ * Options for formatOperateInput function
+ */
+export interface FormatOperateInputOptions {
+    /**
+     * Data to use for placeholder substitution
+     */
+    data?: NaturalMap;
+    /**
+     * Role to use when converting a string to LlmInputMessage
+     */
+    role?: LlmMessageRole;
+}
+/**
+ * Converts various input types to a standardized LlmHistory format
+ * @param input - String, LlmInputMessage, or LlmHistory to format
+ * @param options - Optional configuration
+ * @param options.data - Data to use for placeholder substitution
+ * @param options.role - Role to use when converting a string to LlmInputMessage (defaults to User)
+ * @returns Standardized LlmHistory array
+ */
+export declare function formatOperateInput(input: string | LlmInputMessage | LlmHistory, options?: FormatOperateInputOptions): LlmHistory;

package/dist/util/formatOperateMessage.d.ts

@@ -0,0 +1,24 @@
+import { LlmInputMessage, LlmMessageRole } from "../types/LlmProvider.interface.js";
+import { NaturalMap } from "@jaypie/types";
+/**
+ * Options for formatOperateMessage function
+ */
+export interface FormatOperateMessageOptions {
+    /**
+     * Data to use for placeholder substitution
+     */
+    data?: NaturalMap;
+    /**
+     * Role to use for the message
+     */
+    role?: LlmMessageRole;
+}
+/**
+ * Converts a string to a standardized LlmInputMessage
+ * @param input - String to format
+ * @param options - Optional configuration
+ * @param options.data - Data to use for placeholder substitution
+ * @param options.role - Role to use for the message (defaults to User)
+ * @returns LlmInputMessage
+ */
+export declare function formatOperateMessage(input: string, options?: FormatOperateMessageOptions): LlmInputMessage;

package/dist/util/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./formatOperateInput.js";
+export * from "./formatOperateMessage.js";
+export * from "./logger.js";
+export * from "./maxTurnsFromOptions.js";
+export * from "./naturalZodSchema.js";
+export * from "./random.js";
+export * from "./tryParseNumber.js";

package/dist/util/logger.d.ts

@@ -0,0 +1,71 @@
+import { log as defaultLog } from "@jaypie/core";
+export declare const getLogger: () => {
+    debug: {
+        (...args: unknown[]): void;
+        var(key: string | Record<string, unknown>, value?: unknown): void;
+    };
+    error: {
+        (...args: unknown[]): void;
+        var(key: string | Record<string, unknown>, value?: unknown): void;
+    };
+    fatal: {
+        (...args: unknown[]): void;
+        var(key: string | Record<string, unknown>, value?: unknown): void;
+    };
+    info: {
+        (...args: unknown[]): void;
+        var(key: string | Record<string, unknown>, value?: unknown): void;
+    };
+    trace: {
+        (...args: unknown[]): void;
+        var(key: string | Record<string, unknown>, value?: unknown): void;
+    };
+    warn: {
+        (...args: unknown[]): void;
+        var(key: string | Record<string, unknown>, value?: unknown): void;
+    };
+    var(key: string | Record<string, unknown>, value?: unknown): void;
+    with(tags: Record<string, unknown>): typeof defaultLog;
+    tag(key: string | string[] | Record<string, unknown> | null, value?: string): void;
+    untag(tags: string | string[] | Record<string, unknown> | null): void;
+    lib(options: {
+        level?: string;
+        lib?: string;
+        tags?: Record<string, unknown>;
+    }): typeof defaultLog;
+};
+export declare const log: {
+    debug: {
+        (...args: unknown[]): void;
+        var(key: string | Record<string, unknown>, value?: unknown): void;
+    };
+    error: {
+        (...args: unknown[]): void;
+        var(key: string | Record<string, unknown>, value?: unknown): void;
+    };
+    fatal: {
+        (...args: unknown[]): void;
+        var(key: string | Record<string, unknown>, value?: unknown): void;
+    };
+    info: {
+        (...args: unknown[]): void;
+        var(key: string | Record<string, unknown>, value?: unknown): void;
+    };
+    trace: {
+        (...args: unknown[]): void;
+        var(key: string | Record<string, unknown>, value?: unknown): void;
+    };
+    warn: {
+        (...args: unknown[]): void;
+        var(key: string | Record<string, unknown>, value?: unknown): void;
+    };
+    var(key: string | Record<string, unknown>, value?: unknown): void;
+    with(tags: Record<string, unknown>): typeof defaultLog;
+    tag(key: string | string[] | Record<string, unknown> | null, value?: string): void;
+    untag(tags: string | string[] | Record<string, unknown> | null): void;
+    lib(options: {
+        level?: string;
+        lib?: string;
+        tags?: Record<string, unknown>;
+    }): typeof defaultLog;
+};

package/dist/util/maxTurnsFromOptions.d.ts

@@ -0,0 +1,10 @@
+import { LlmOperateOptions } from "../types/LlmProvider.interface.js";
+export declare const MAX_TURNS_ABSOLUTE_LIMIT = 72;
+export declare const MAX_TURNS_DEFAULT_LIMIT = 12;
+/**
+ * Determines the maximum number of turns based on the provided options
+ *
+ * @param options - The LLM operate options
+ * @returns The maximum number of turns
+ */
+export declare function maxTurnsFromOptions(options: LlmOperateOptions): number;

package/dist/util/naturalZodSchema.d.ts

@@ -1,3 +1,3 @@
 import { z } from "zod";
 import { NaturalSchema } from "@jaypie/types";
-export default function naturalZodSchema(definition: NaturalSchema): z.ZodTypeAny;
+export declare function naturalZodSchema(definition: NaturalSchema): z.ZodTypeAny;

package/dist/util/random.d.ts

@@ -35,5 +35,5 @@ export declare const DEFAULT_MAX = 1;
  * // Use consistent seeding
  * const seeded = rng({ seed: "my-seed" });
  */
-declare const random: (defaultSeed?: string) => RandomFunction;
-export default random;
+export declare function random(defaultSeed?: string): RandomFunction;
+export {};

package/dist/util/tryParseNumber.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Options for tryParseNumber function
+ */
+export interface TryParseNumberOptions {
+    /**
+     * Default value to return if parsing fails or results in NaN
+     */
+    defaultValue?: number;
+    /**
+     * Function to call with warning message if parsing fails or results in NaN
+     */
+    warnFunction?: (message: string) => void;
+}
+/**
+ * Attempts to parse a value as a number. Returns the original input if parsing fails or results in NaN.
+ * @param input - The value to attempt to parse as a number
+ * @param options - Optional configuration
+ * @param options.defaultValue - Default value to return if parsing fails or results in NaN
+ * @param options.warnFunction - Function to call with warning message if parsing fails or results in NaN
+ * @returns The parsed number, defaultValue (if specified and parsing fails), or the original input
+ */
+export declare function tryParseNumber(input: unknown, options?: TryParseNumberOptions): number | unknown;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jaypie/llm",
-  "version": "1.1.6",
+  "version": "1.1.8",
   "description": "Large language model utilities",
   "license": "MIT",
   "author": "Finlayson Studio",
@@ -37,5 +37,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "1026f2fc0b3f6ae0ca2e1b6495437364f1c4e6fe"
+  "gitHead": "147d2cc66ce944e37e2225760fd71a72e761a37a"
 }