@jaypie/llm 1.1.5 → 1.1.7

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

@@ -1,7 +1,96 @@
-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;
+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;
@@ -10,6 +99,43 @@ export interface LlmMessageOptions {
     response?: NaturalSchema | z.ZodType;
     system?: string;
 }
+export interface LlmOperateOptions {
+    data?: NaturalMap;
+    explain?: boolean;
+    format?: JsonObject | NaturalSchema | z.ZodType;
+    history?: LlmHistory;
+    instructions?: string;
+    model?: string;
+    placeholders?: {
+        input?: boolean;
+        instructions?: boolean;
+    };
+    providerOptions?: Record<string, AnyValue>;
+    tools?: LlmTool[];
+    turns?: boolean | number;
+    user?: string;
+}
+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 | LlmHistory | LlmInputMessage, options?: LlmOperateOptions): Promise<LlmOperateResponse>;
     send(message: string, options?: LlmMessageOptions): Promise<string | JsonObject>;
 }
+export {};

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

@@ -0,0 +1,8 @@
+import { AnyValue, JsonObject } from "@jaypie/types";
+export interface LlmTool {
+    description: string;
+    name: string;
+    parameters: JsonObject;
+    type: "function" | string;
+    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

@@ -0,0 +1,39 @@
+interface RandomOptions {
+    min?: number;
+    max?: number;
+    mean?: number;
+    stddev?: number;
+    integer?: boolean;
+    start?: number;
+    seed?: string;
+    precision?: number;
+    currency?: boolean;
+}
+type RandomFunction = {
+    (options?: RandomOptions): number;
+};
+export declare const DEFAULT_MIN = 0;
+export declare const DEFAULT_MAX = 1;
+/**
+ * Creates a random number generator with optional seeding
+ *
+ * @param defaultSeed - Seed string for the default RNG
+ * @returns A function that generates random numbers based on provided options
+ *
+ * @example
+ * const rng = random("default-seed");
+ *
+ * // Generate a random float between 0 and 1
+ * const basic = rng();
+ *
+ * // Generate an integer between 1 and 10
+ * const integer = rng({ min: 1, max: 10, integer: true });
+ *
+ * // Generate from normal distribution
+ * const normal = rng({ mean: 50, stddev: 10 });
+ *
+ * // Use consistent seeding
+ * const seeded = rng({ seed: "my-seed" });
+ */
+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.5",
+  "version": "1.1.7",
   "description": "Large language model utilities",
   "license": "MIT",
   "author": "Finlayson Studio",
@@ -17,7 +17,7 @@
     "dist"
   ],
   "scripts": {
-    "build": "rollup --config",
+    "build:manual": "rollup --config",
     "format": "eslint . --fix",
     "lint": "eslint .",
     "test": "vitest run .",
@@ -26,14 +26,16 @@
   "dependencies": {
     "@jaypie/aws": "^1.1.15",
     "@jaypie/core": "^1.1.2",
-    "openai": "^4.82.0",
+    "openai": "^4.87.3",
+    "openmeteo": "^1.2.0",
+    "random": "^5.3.0",
     "zod": "^3.24.1"
   },
   "devDependencies": {
-    "@jaypie/types": "^0.1.2"
+    "@jaypie/types": "^0.1.3"
   },
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "444299036d617cc9916c9b74cf48781680a98208"
+  "gitHead": "8afa77184376db70544710e7414de80ed3a0f60a"
 }

package/dist/__tests__/Llm.class.spec.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/__tests__/constants.spec.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/__tests__/index.spec.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/providers/OpenAiProvider.class.d.ts

@@ -1,13 +0,0 @@
-import { JsonObject } from "@jaypie/types";
-import { LlmProvider, LlmMessageOptions } from "../types/LlmProvider.interface.js";
-export declare class OpenAiProvider implements LlmProvider {
-    private model;
-    private _client?;
-    private apiKey?;
-    private log;
-    constructor(model?: string, { apiKey }?: {
-        apiKey?: string;
-    });
-    private getClient;
-    send(message: string, options?: LlmMessageOptions): Promise<string | JsonObject>;
-}

package/dist/providers/__tests__/OpenAiProvider.spec.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/util/__tests__/naturalZodSchema.spec.d.ts

@@ -1 +0,0 @@
-export {};