@j-o-r/hello-dave 0.0.0

package/types/AgentClient.d.ts

@@ -0,0 +1,70 @@
+export default AgentClient;
+export type OARequest = typeof import("./API/openai.com/reponses/text.js").request;
+export type XRequest = typeof import("./API/x.ai/text.js").request;
+export type ANTHRequest = typeof import("./API/anthropic.com/text.js").request;
+export type XOptions = import("./API/x.ai/text.js").XOptions;
+export type OAOptions = import("./API/openai.com/reponses/text.js").OAOptions;
+export type ANTHOptions = import("./API/anthropic.com/text.js").ANTHOptions;
+export type Prompt = import("./Prompt.js").default;
+export type ToolSet = import("./ToolSet.js").default;
+export type WSOptions = {
+    /**
+     * - The prompt session
+     */
+    prompt: Prompt;
+    /**
+     * - The toolset
+     */
+    toolset?: import("./ToolSet.js").default | undefined;
+    /**
+     * - Custom introduction message.
+     */
+    description: string;
+    /**
+     * - Logical name: e.g. search, code, os, support.
+     */
+    name: string;
+    url?: string | undefined;
+    /**
+     * - How often to pull one message from the queue.
+     */
+    intervalMs?: number | undefined;
+};
+/**
+* @typedef {import('./API/openai.com/reponses/text.js').request} OARequest
+* @typedef {import('./API/x.ai/text.js').request} XRequest
+* @typedef {import('./API/anthropic.com/text.js').request} ANTHRequest
+*
+* @typedef {import('./API/x.ai/text.js').XOptions} XOptions
+* @typedef {import('./API/openai.com/reponses/text.js').OAOptions} OAOptions
+* @typedef {import('./API/anthropic.com/text.js').ANTHOptions} ANTHOptions
+*
+* @typedef {import('./Prompt.js').default} Prompt
+* @typedef {import('./ToolSet.js').default} ToolSet
+*/
+/**
+* @typedef {Object} WSOptions
+* @property {Prompt} prompt - The prompt session
+* @property {ToolSet} [toolset] - The toolset
+* @property {string} description - Custom introduction message.
+* @property {string} name - Logical name: e.g. search, code, os, support.
+* @property {string} [url='ws://127.0.0.1:8000/ws?params=1234']
+* @property {number} [intervalMs=250] - How often to pull one message from the queue.
+*/
+/**
+* Websocket Client
+* Wrapper combining a session and a websocket
+*/
+declare class AgentClient {
+    /**
+     * Creates an instance of CLILoader.
+     * @param {WSOptions} options - The options to configure the CLILoader.
+     */
+    constructor(options: WSOptions);
+    _start(): void;
+    /**
+    * Enqueue an incoming websocket message and trigger the processor.
+    */
+    incoming(e: any): void;
+    #private;
+}

package/types/AgentManager.d.ts

@@ -0,0 +1,112 @@
+export default AgentManager;
+export type XOptions = import("./API/x.ai/text.js").XOptions;
+export type OAOptions = import("./API/openai.com/reponses/text.js").OAOptions;
+export type ANTHOptions = import("./API/anthropic.com/text.js").ANTHOptions;
+export type Setup = {
+    /**
+     * - Initial system prompt
+     */
+    prompt: string;
+    /**
+     * - Model options
+     */
+    options: OAOptions | XOptions | ANTHOptions;
+    /**
+     * - AI endpoint to use
+     */
+    api: "gpt" | "grok" | "claude";
+    /**
+     * - The size in tokens for the context/session
+     */
+    contextWindow?: number | undefined;
+    /**
+     * -
+     */
+    toolsetMode?: void | "auto" | "required" | undefined;
+    /**
+     * - verbose output
+     */
+    debug?: boolean | undefined;
+};
+export type Options = {
+    /**
+     * - Agent name
+     */
+    name: string;
+    /**
+     * - path to session/record storage
+     */
+    cachePath?: string | undefined;
+};
+/**
+* @typedef {import('./API/x.ai/text.js').XOptions} XOptions
+* @typedef {import('./API/openai.com/reponses/text.js').OAOptions} OAOptions
+* @typedef {import('./API/anthropic.com/text.js').ANTHOptions} ANTHOptions
+*/
+/**
+* @typedef {Object} Setup
+* @property {string} prompt - Initial system prompt
+* @property {OAOptions|XOptions|ANTHOptions} options - Model options
+* @property {'gpt'|'grok'|'claude'} api - AI endpoint to use
+* @property {number} [contextWindow] - The size in tokens for the context/session
+* @property {'auto'|'required'|void} [toolsetMode] -
+* @property {boolean} [debug] - verbose output
+*/
+/**
+* @typedef {Object} Options
+* @property {string} name - Agent name
+* @property {string} [cachePath] - path to session/record storage
+*/
+declare class AgentManager {
+    /**
+    * @param {Options} options
+    */
+    constructor(options: Options);
+    /**
+    * @param {Setup} setup
+    */
+    setup(setup: Setup): this;
+    /**
+    * Start a CLI for local usage
+    * @param {string} description - introduction message for the CLI user
+    */
+    startCli(description: string): void;
+    /**
+    * Attach a session to an AgentServer
+    * DO NOT ATTACH TO SELF, however, when in server mode
+    * An AgentServer can attach as client to another server
+    * @param {string} name - function_call name
+    * @param {string} description - function_call description
+    * @param {string} [url='ws://127.0.0.1:8000/ws'] - ws URL
+    */
+    attach(name: string, description: string, url?: string): AgentClient;
+    /**
+    * Start the Agent in server mode.
+    * A server is always started on localhost
+    * Clients can attach now and are accesible as via function_calls (toolset)
+    * @param {string} name - function_call name
+    * @param {string} description - function_call description
+    * @param {number} [port=8000] - Start the dynamic toolset server on this port
+    */
+    enableServer(name: string, description?: string, port?: number): void;
+    /**
+    * Direct call to the prompt
+    * @param {string} input
+    * @returns {Promise<string>}
+    */
+    directCall(input: string): Promise<string>;
+    /** @returns {Prompt} */
+    getPrompt(): Prompt;
+    /** @returns {ToolSet|void} */
+    getToolset(): ToolSet | void;
+    /** @returns {Promise<import('./fafs.js').EnvironmentInfo>} */
+    environment(): Promise<import("./fafs.js").EnvironmentInfo>;
+    /**
+    * @param {string} name - the toolname
+    */
+    addGenericToolcall(name: string): void;
+    #private;
+}
+import { AgentClient } from './index.js';
+import { Prompt } from './index.js';
+import { ToolSet } from './index.js';

package/types/AgentServer.d.ts

@@ -0,0 +1,38 @@
+export default AgentServer;
+export type Client = import("../node_modules/@j-o-r/apiserver/types/ClientWrapper.d.ts").ClientWrapper;
+export type Prompt = import("./Prompt.js").default;
+export type ToolSet = import("./ToolSet.js").default;
+export type Session = import("./Session.js").default;
+export type AuthFunction = (conn: import("@j-o-r/apiserver/types/WebSocketServer.js").WebSocketConnection) => Promise<boolean>;
+export type AgentServerOptions = {
+    name: string;
+    description: string;
+    prompt: Prompt;
+    session: Session;
+    auth?: AuthFunction | undefined;
+    /**
+     * - default 8000
+     */
+    port?: number | undefined;
+    debug?: boolean | undefined;
+};
+declare class AgentServer {
+    /**
+    * @param {AgentServerOptions} options
+    */
+    constructor(options: AgentServerOptions);
+    /**
+    * @private
+    * Returns a Dynamic Toolset
+    * With registered WS clients as toolcalls
+    * A deamon start on local host 127.0.0.1, always
+    * @returns {Promise<void>}
+    */
+    private _start;
+    /**
+    * Send a reset messages to all clients
+    * reset will start a new session
+    */
+    resetAll(): void;
+    #private;
+}

package/types/Cli.d.ts

@@ -0,0 +1,52 @@
+export default Cli;
+export type OARequest = typeof import("./API/openai.com/reponses/text.js").request;
+export type XRequest = typeof import("./API/x.ai/text.js").request;
+export type ANTHRequest = typeof import("./API/anthropic.com/text.js").request;
+export type XOptions = import("./API/x.ai/text.js").XOptions;
+export type OAOptions = import("./API/openai.com/reponses/text.js").OAOptions;
+export type ANTHOptions = import("./API/anthropic.com/text.js").ANTHOptions;
+export type Prompt = import("./Prompt.js").default;
+export type Session = import("./Session.js").default;
+export type ToolSet = import("./ToolSet.js").default;
+export type CLIOptions = {
+    /**
+     * - The prompt session
+     */
+    prompt: Prompt;
+    /**
+     * - Session  Cache
+     */
+    session: Session;
+    /**
+     * - The toolset
+     */
+    toolset?: import("./ToolSet.js").default | undefined;
+    /**
+     * - Custom introduction message.
+     */
+    description?: string | undefined;
+    /**
+     * - Custom help message.
+     */
+    help?: string | undefined;
+};
+/**
+ * CLILoader class for handling CLI-based interactions with AI models.
+ */
+declare class Cli {
+    /**
+     * Creates an instance of CLILoader.
+     * @param {CLIOptions} options - The options to configure the CLILoader.
+     */
+    constructor(options: CLIOptions);
+    printInfo(): void;
+    /**
+     * Starts the CLI interaction.
+     * @param {string} [s] - optional user string/question
+     * @returns {Promise<void>}
+     */
+    start(s?: string): Promise<void>;
+    loadSession(): Promise<void>;
+    reset(): Promise<void>;
+    #private;
+}

package/types/Prompt.d.ts

@@ -0,0 +1,298 @@
+export default Prompt;
+export type OARequest = typeof import("./API/openai.com/reponses/text.js").request;
+export type XRequest = typeof import("./API/x.ai/text.js").request;
+export type ANTHRequest = typeof import("./API/anthropic.com/text.js").request;
+export type XOptions = import("./API/x.ai/text.js").XOptions;
+export type OAOptions = import("./API/openai.com/reponses/text.js").OAOptions;
+export type ANTHOptions = import("./API/anthropic.com/text.js").ANTHOptions;
+export type ToolSet = import("./ToolSet.js").default;
+/**
+ * - The AI model to use for chat functionality.
+ */
+export type request = OARequest | XRequest | ANTHRequest;
+/**
+ * - Model options
+ */
+export type options = OAOptions | XOptions | ANTHOptions;
+export type Roles = "system" | "assistant" | "user" | "tool" | "log" | "reasoning";
+export type Record = {
+    /**
+     * - remote request id or generated requestId
+     */
+    id: string;
+    /**
+     * - Date in ISO string format
+     */
+    isoDate: string;
+    /**
+     * - Execution time in MS of the model / method
+     */
+    duration: number;
+    /**
+     * - Execution context endpoint_name / server_name / interpreter_name
+     */
+    environment: string;
+    /**
+     * - LLM model, method , funtion name
+     */
+    model: string;
+    /**
+     * - Number of tokens to process
+     */
+    tokensIn: number;
+    /**
+     * - Number of tokens in the response
+     */
+    tokensOut: number;
+};
+export type TextMessage = {
+    /**
+     * ="text" - The type of the message, should be "text".
+     */
+    type: string;
+    /**
+     * - The content of the text message.
+     */
+    text: string;
+};
+export type ImageMessage = {
+    /**
+     * ="image_url" - The type of the message, should be "image_url".
+     */
+    type: string;
+    /**
+     * - URL or "data:image/png;base64,{base64_image}"
+     */
+    url: string;
+};
+export type AudioMessage = {
+    /**
+     * ="url" - The type of the message, should be "image_url".
+     */
+    type: string;
+    /**
+     * - URL or "data:image/png;base64,{base64_image}"
+     */
+    url: string;
+};
+/**
+ * The `PRMessagerole.role` must be 'assistant'
+ */
+export type FunctionRequest = {
+    /**
+     * - The type of the message, should be "function_request".
+     */
+    type: "function_request";
+    /**
+     * - Function object with properties
+     */
+    function_request: {
+        name: string;
+        id: string;
+        call_id: string;
+        parameters: string;
+    };
+};
+/**
+ * The `PRMessage.role` must 'tool'
+ */
+export type FunctionResponse = {
+    /**
+     * - The type of the message, should be "function_response".
+     */
+    type: "function_response";
+    /**
+     * - Function object with properties
+     */
+    function_response: {
+        name: string;
+        id: string;
+        call_id: string;
+        response: string;
+    };
+};
+export type Content = TextMessage | ImageMessage | AudioMessage | FunctionRequest | FunctionResponse;
+export type Message = {
+    /**
+     * -  Message role
+     */
+    role: Roles;
+    /**
+     * -
+     */
+    content: Content[];
+    /**
+     * - optional author name
+     */
+    name?: string | undefined;
+    /**
+     * - This message object is part of the base prompt (reuse after reset) and is not truncated
+     */
+    sticky?: boolean | undefined;
+    /**
+     * - A timestamp in MS for reconstruction truncated prompts (for creating large context embeddings)
+     */
+    ts?: number | undefined;
+};
+/**
+*
+* @fires Prompt#add
+* Event: message added
+*
+* @event Prompt#add
+* @type {Message}
+*/
+declare class Prompt {
+    /**
+    * Constructs a new Prompt instance.
+    * If contextWindow = 0 (defaut) the prompt will have no context building up (ONE_SHOT)
+    * @param {number} [contextWindow] - The max size of a total prompt in tokens. (context)
+    */
+    constructor(contextWindow?: number);
+    EVENTS: Readonly<{
+        start: string;
+        retrigger: string;
+        finished: string;
+        message: string;
+        record: string;
+        truncated: string;
+        reset: string;
+        ready: string;
+        error: string;
+        warning: string;
+        tool_request: string;
+        tool_response: string;
+        tool_error: string;
+        http_request: string;
+        http_response: string;
+    }>;
+    /**
+    * @param {request} handler
+    * @param {ToolSet} toolset
+    * @param {options} options
+    */
+    setAdaptor(handler: request, toolset: ToolSet, options: options): void;
+    /**
+    * Get the names of the available funtion calls
+    * @returns {string[]}
+    */
+    toolsetFunctions(): string[];
+    /**
+    * @returns {ToolSet|void}
+    */
+    get toolset(): ToolSet | void;
+    /**
+    * Start a requests
+    * @param {string|Content} content
+    * @returns {Promise<string>}
+    */
+    call(content: string | Content): Promise<string>;
+    /**
+    * Trigger a request when the last added message is a user or tool message
+    * Exit on error
+    */
+    triggerRequest(): Promise<void>;
+    /**
+    * Get the maximum token length for this prompt
+    * @returns {number}
+    */
+    get contextLength(): number;
+    /**
+    * Imports messages.
+    * Bypasses the event emitter
+    * @param {Message[]} messages
+    * @throws {Error} If the input string is invalid.
+    */
+    set messages(messages: Message[]);
+    /**
+    * Returns a copy of the messages array.
+    * @returns {Message[]} - A copy of the messages array.
+    */
+    get messages(): Message[];
+    /**
+    * Return the most recent, the LAST message added
+    * @returns {Message|void}
+    */
+    getLastMessage(): Message | void;
+    /**
+    * Return the readable content (type == text)
+    * @param {Content[]} content
+    * @return {string}
+    */
+    contentToString(content: Content[]): string;
+    /**
+    * Count the number of tokens on a given string
+    * Or the recorded tokencount of the last roundtrip
+    * @param {string} [str] - the string to count
+    * @param returns {number}
+    */
+    countTokens(str?: string): number;
+    /**
+    * reduce the prompt length to fit in the contextWindow
+    * or simply reset when there is no contextWindow
+    * @returns {boolean} true when the prompt has been altered/reduced
+    */
+    truncate(): boolean;
+    /**
+    * Gets the length of the messages array.
+    * @returns {number} - The length of the messages array.
+    */
+    get length(): number;
+    /**
+    * Gets the system prompt from the messages.
+    * @returns {string} - The system prompt.
+    * @throws {Error} If no system prompt is available.
+    */
+    get system_prompt(): string;
+    /**
+    * Checks if a system prompt is available.
+    * @returns {boolean} - True if a system prompt is available, false otherwise.
+    */
+    get hasSystemprompt(): boolean;
+    /**
+    * Adds a text message to the messages array.
+    * @param {Roles} role - The role of the message.
+    * @param {string} message - The text message.
+    * @param {boolean} [sticky] - Whether the message is part of the base prompt.
+    * @fires Prompt#message
+    * @throws {Error} If the message order is invalid or the message is invalid.
+    */
+    add(role: Roles, message: string, sticky?: boolean): void;
+    /**
+    * Adds a multi-modal message to the messages array.
+    * @param {Roles} role - The role of the message.
+    * @param {Content[]} messages - The actual messages with multi-modal content.
+    * @param {boolean} [sticky] - Whether the message is part of the base prompt.
+    * @fires Prompt#add
+    * @throws {Error} If the message order is invalid or the messages are invalid.
+    */
+    addMultiModal(role: Roles, messages: Content[], sticky?: boolean): void;
+    /**
+    * Removes all non-sticky messages and returns them
+    * Keeps the 'base' (sticky) prompt/messages.
+    * @returns {Message[]}
+    */
+    reset(): Message[];
+    /**
+    * Register a record from the adapter
+    * @param {Record} record - Records for billing and optimizing
+    * @throws {Error} If the record is invalid.
+    */
+    addRecord(record: Record): void;
+    /**
+    * Add a list of records (with multiple prompts to maintain a full history of events)
+    * @param {Record[]} records - Records for billing and optimizing
+    * @throws {Error} If the record is invalid.
+    */
+    addRecords(records: Record[]): void;
+    /**
+    * Template record
+    * @returns {Record}
+    */
+    templateRecord(): Record;
+    /**
+    * Gather metrics as info
+    */
+    info(): string;
+    #private;
+}

package/types/Session.d.ts

@@ -0,0 +1,31 @@
+export default Session;
+export type Message = import("./Prompt.js").Message;
+export type Record = import("./Prompt.js").Record;
+/**
+ */
+declare class Session {
+    /**
+    * Constructs a new Prompt instance.
+    * If contextWindow = 0 (defaut) the prompt will have no context building up (ONE_SHOT)
+    * @param {string} name - The name of the prompt.
+    * @param {Prompt} prompt - The prompt
+    * @param {string} [storage] - The base storage folder, default this is process.cwd()
+    */
+    constructor(name: string, prompt: Prompt, storage?: string);
+    name: string | undefined;
+    info(): string;
+    sessionList(): string[];
+    /**
+    * Get messages fro, a session
+    *
+    * @param {string} sess - The session name.
+    * @return {Message[]}
+    */
+    set(sess: string): Message[];
+    /**
+    * Remove all previous sessions and records
+    */
+    empty(): void;
+    #private;
+}
+import Prompt from './Prompt.js';

package/types/ToolSet.d.ts

@@ -0,0 +1,95 @@
+export default ToolSet;
+export type TSSchema = {
+    /**
+     * - Type of the object
+     */
+    type: string;
+    /**
+     * - Description of properties
+     */
+    properties: object;
+    /**
+     * - Required properties
+     */
+    required?: string[] | undefined;
+};
+export type TSTool = {
+    /**
+     * - Command description
+     */
+    description: string;
+    /**
+     * - JS JSON schema
+     */
+    parameters: TSSchema;
+    method: (arg0: object) => Promise<any>;
+};
+export type TSToolListItem = {
+    /**
+     * - Command name
+     */
+    name: string;
+    /**
+     * - Command description
+     */
+    description: string;
+    /**
+     * - JS JSON schema
+     */
+    parameters: TSSchema;
+};
+declare class ToolSet {
+    /**
+    * @param {string} [choice] - Default 'auto' auto|none|required
+    */
+    constructor(choice?: string);
+    /**
+    * How many functions have we registered
+    * @returns {number}
+    */
+    get length(): number;
+    /**
+    * Register a Tool/Command/Function
+    * @param {string} name - [a-z_0-9]{2,} The lowercase string name of the callback e.g. 'get_node_version'
+    * @param {string} description - What does it do
+    * @param {TSSchema} parameters - SCHEMA object describing the function's input parameters
+    * @param {function(object): Promise<*>} method - Async function to call
+    */
+    add(name: string, description: string, parameters: TSSchema, method: (arg0: object) => Promise<any>): void;
+    /**
+    * Get a  tool from the toolset
+    * @param {string} name
+    * @returns {TSTool}
+    */
+    get(name: string): TSTool;
+    /**
+    * Delete a function_call
+    * @param {string} name
+    */
+    delete(name: string): void;
+    /**
+    * Is 'name' already registered
+    * @param {string} name
+    * @returns {boolean}
+    */
+    has(name: string): boolean;
+    /**
+    * Get a list of tools available
+    * @returns {TSToolListItem[]}
+    */
+    list(): TSToolListItem[];
+    get toolChoice(): string;
+    /**
+    * Execute a method
+    * @param {string} name
+    * @param {object} params
+    */
+    call(name: string, params: object): Promise<any>;
+    /**
+     * Execute function requests from the last message.
+     * @param {Prompt} prompt - Handle tool calls.
+     */
+    execute(prompt: Prompt): Promise<void>;
+    #private;
+}
+import Prompt from "./Prompt.js";