@xalia/agent 0.5.0

package/dist/openAILLMStreaming.js

@@ -0,0 +1,431 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenAILLMStreaming = void 0;
+const sdk_1 = require("@xalia/xmcp/sdk");
+const openai_1 = require("openai");
+const assert_1 = require("assert");
+const logger = (0, sdk_1.getLogger)();
+function initialToolCallFunction(deltaFn) {
+    //   export interface ChatCompletionChunk.Choice.Delta.ToolCall.Function {
+    //     arguments?: string;
+    //     name?: string;
+    //   }
+    //
+    // ->
+    //
+    //   export interface Function {
+    //     arguments: string;
+    //     name: string;
+    //   }
+    return {
+        arguments: deltaFn?.arguments || "",
+        name: deltaFn?.name || "",
+    };
+}
+function updateToolCallFunction(existingFn, deltaFn // eslint-disable-line
+) {
+    //   export interface ChatCompletionChunk.Choice.Delta.ToolCall.Function {
+    //     arguments?: string;
+    //     name?: string;
+    //   }
+    // ->
+    //   export interface Function {
+    //     arguments: string;
+    //     name: string;
+    //   }
+    // The function can have either (or possibly both) field(s) empty.
+    // `arguments` has been observered to arrive in chunks.  The same is
+    // probably true of `name`.
+    if (!deltaFn) {
+        return;
+    }
+    if (deltaFn.name) {
+        existingFn.name += deltaFn.name;
+    }
+    if (deltaFn.arguments) {
+        existingFn.arguments += deltaFn.arguments;
+    }
+}
+function initialToolCall(delta) {
+    return {
+        id: delta.id || "",
+        function: initialToolCallFunction(delta.function),
+        type: "function",
+    };
+}
+function updateToolCall(existing, delta) {
+    //   export interface ChatCompletionChunk.Choice.Delta.ToolCall {
+    //     index: number;
+    //     id?: string;
+    //     function?: ToolCall.Function;
+    //     type?: 'function';
+    //   }
+    //
+    // ->
+    //
+    //   export interface ChatCompletionMessageToolCall {
+    //     id: string;
+    //     function: ChatCompletionMessageToolCall.Function;
+    //     type: 'function';
+    //   }
+    if (delta.id) {
+        if (existing.id.length > 0) {
+            (0, assert_1.strict)(delta.id == existing.id);
+        }
+        else {
+            existing.id = delta.id;
+        }
+    }
+    if (delta.function) {
+        updateToolCallFunction(existing.function, delta.function);
+    }
+    if (delta.type) {
+        (0, assert_1.strict)((delta.type = "function"));
+    }
+}
+function updateToolCalls(toolCalls, deltaToolCall // eslint-disable-line
+) {
+    //   export interface ChatCompletionChunk.Choice.Delta.ToolCall {
+    //     index: number;
+    //     id?: string;
+    //     function?: ToolCall.Function;
+    //     type?: 'function';
+    //   }
+    //
+    // ->
+    //
+    //   export interface ChatCompletionMessageToolCall {
+    //     id: string;
+    //     function: ChatCompletionMessageToolCall.Function;
+    //     type: 'function';
+    //   }
+    // The delta can arrive with any or none of the given fields.  Only `index`
+    // can be relied upon.
+    if (typeof toolCalls === "undefined") {
+        toolCalls = [];
+    }
+    const existing = toolCalls[deltaToolCall.index];
+    if (!existing) {
+        toolCalls[deltaToolCall.index] = initialToolCall(deltaToolCall);
+    }
+    else {
+        updateToolCall(toolCalls[deltaToolCall.index], deltaToolCall);
+    }
+    return toolCalls;
+}
+function initializeCompletionMessage(delta) {
+    (0, assert_1.strict)(delta.role === undefined || delta.role == "assistant");
+    (0, assert_1.strict)(!delta.function_call);
+    //   export interface ChatCompletionChunk.Choice.Delta {
+    //     content?: string | null;
+    //     function_call?: Delta.FunctionCall;
+    //     refusal?: string | null;
+    //     role?: 'developer' | 'system' | 'user' | 'assistant' | 'tool';
+    //     tool_calls?: Array<Delta.ToolCall>;
+    //   }
+    //
+    // ->
+    //
+    //   export interface ChatCompletionMessage {
+    //     content: string | null;
+    //     refusal: string | null;
+    //     role: 'assistant';
+    //     annotations?: Array<ChatCompletionMessage.Annotation>;
+    //     audio?: ChatCompletionAudio | null;
+    //     function_call?: ChatCompletionMessage.FunctionCall | null;
+    //     tool_calls?: Array<ChatCompletionMessageToolCall>;
+    //   }
+    let toolCalls = undefined;
+    if (delta.tool_calls) {
+        for (const t of delta.tool_calls) {
+            toolCalls = updateToolCalls(toolCalls, t);
+        }
+    }
+    return {
+        content: delta.content || null,
+        refusal: delta.refusal || null,
+        role: "assistant",
+        // annotations?: Array<ChatCompletionMessage.Annotation>;
+        // audio?: ChatCompletionAudio | null;
+        // function_call: delta.function_call,
+        tool_calls: toolCalls,
+    };
+}
+function updateCompletionMessage(message, delta) {
+    (0, assert_1.strict)(message.role === "assistant");
+    (0, assert_1.strict)(!message.function_call);
+    (0, assert_1.strict)(!message.audio);
+    (0, assert_1.strict)(message.tool_calls instanceof Array ||
+        typeof message.tool_calls === "undefined");
+    //   export interface ChatCompletionChunk.Choice.Delta {
+    //     content?: string | null;
+    //     function_call?: Delta.FunctionCall;
+    //     refusal?: string | null;
+    //     role?: 'developer' | 'system' | 'user' | 'assistant' | 'tool';
+    //     tool_calls?: Array<Delta.ToolCall>;
+    //   }
+    //
+    // ->
+    //
+    //   export interface ChatCompletionMessage {
+    //     content: string | null;
+    //     refusal: string | null;
+    //     role: 'assistant';
+    //     annotations?: Array<ChatCompletionMessage.Annotation>;
+    //     audio?: ChatCompletionAudio | null;
+    //     function_call?: ChatCompletionMessage.FunctionCall | null;
+    //     tool_calls?: Array<ChatCompletionMessageToolCall>;
+    //   }
+    if (delta.content) {
+        if (message.content) {
+            message.content += delta.content;
+        }
+        else {
+            message.content = delta.content;
+        }
+    }
+    (0, assert_1.strict)(!delta.function_call);
+    if (delta.refusal) {
+        if (message.refusal) {
+            message.refusal += delta.refusal;
+        }
+        else {
+            message.refusal = delta.refusal;
+        }
+    }
+    (0, assert_1.strict)(delta.role === undefined || delta.role == "assistant");
+    if (delta.tool_calls) {
+        for (const t of delta.tool_calls) {
+            message.tool_calls = updateToolCalls(message.tool_calls, t);
+        }
+    }
+}
+function initializeCompletionChoice(chunkChoice) {
+    //   export interface ChatCompletionChunk.Choice {
+    //     delta: Choice.Delta;
+    //     finish_reason:
+    //       'stop'|'length'|'tool_calls'|'content_filter'|'function_call'|null;
+    //     index: number;
+    //     logprobs?: Choice.Logprobs | null;
+    //   }
+    //
+    // ->
+    //
+    //   export interface ChatCompletion.Choice {
+    //     message: CompletionsCompletionsAPI.ChatCompletionMessage;
+    //     finish_reason:
+    //         'stop'|'length'|'tool_calls'|'content_filter'|'function_call';
+    //     index: number;
+    //     logprobs: Choice.Logprobs | null;
+    //   }
+    const message = initializeCompletionMessage(chunkChoice.delta);
+    return {
+        choice: {
+            message,
+            finish_reason: chunkChoice.finish_reason || "stop",
+            index: chunkChoice.index,
+            logprobs: chunkChoice.logprobs || null,
+        },
+        done: !!chunkChoice.finish_reason,
+    };
+}
+function updateCompletionChoice(completionChoice, chunkChoice) {
+    //   export interface ChatCompletionChunk.Choice {
+    //     delta: Choice.Delta;
+    //     finish_reason:
+    //       'stop'|'length'|'tool_calls'|'content_filter'|'function_call'|null;
+    //     index: number;
+    //     logprobs?: Choice.Logprobs | null;
+    //   }
+    //
+    // ->
+    //
+    //   export interface ChatCompletion.Choice {
+    //     message: CompletionsCompletionsAPI.ChatCompletionMessage;
+    //     finish_reason:
+    //         'stop'|'length'|'tool_calls'|'content_filter'|'function_call';
+    //     index: number;
+    //     logprobs: Choice.Logprobs | null;
+    //   }
+    // TODO: logprobs
+    (0, assert_1.strict)(completionChoice.index === chunkChoice.index);
+    updateCompletionMessage(completionChoice.message, chunkChoice.delta);
+    if (chunkChoice.finish_reason) {
+        completionChoice.finish_reason = chunkChoice.finish_reason;
+        return true;
+    }
+    return false;
+}
+function initializeCompletionChoices(chunkChoices) {
+    // Technically, one choice could be done and the other still have some
+    // content to stream.  We keep it simple for now and assume only single
+    // choices, which allows us to mark everything as done if any choice we hit is
+    // done.
+    (0, assert_1.strict)(chunkChoices.length === 1);
+    let msgDone = false;
+    const choices = [];
+    for (const chunkChoice of chunkChoices) {
+        const { choice, done } = initializeCompletionChoice(chunkChoice);
+        if (done) {
+            msgDone = true;
+        }
+        choices[chunkChoice.index] = choice;
+    }
+    return { choices, done: msgDone };
+}
+function updateCompletionChoices(completionChoices, chunkChoices) {
+    // Technically, one choice could be done and the other still have some
+    // content to stream.  We keep it simple for now and assume only single
+    // choices, which allows us to mark everything as done if any choice we hit is
+    // done.
+    (0, assert_1.strict)(chunkChoices.length === 1);
+    (0, assert_1.strict)(completionChoices.length === 1);
+    let msgDone = false;
+    for (const chunkChoice of chunkChoices) {
+        const choiceIdx = chunkChoice.index;
+        const done = updateCompletionChoice(completionChoices[choiceIdx], chunkChoice);
+        if (done) {
+            msgDone = true;
+        }
+    }
+    return msgDone;
+}
+function initializeCompletion(chunk) {
+    //   export interface ChatCompletionChunk {
+    //     id: string;
+    //     choices: Array<ChatCompletionChunk.Choice>;
+    //     created: number;
+    //     model: string;
+    //     object: 'chat.completion.chunk';
+    //     service_tier?: 'auto' | 'default' | 'flex' | null;
+    //     system_fingerprint?: string;
+    //     usage?: CompletionsAPI.CompletionUsage | null;
+    //   }
+    //
+    // ->
+    //
+    //   export interface ChatCompletion {
+    //     id: string;
+    //     choices: Array<ChatCompletion.Choice>;
+    //     created: number;
+    //     model: string;
+    //     object: 'chat.completion';
+    //     service_tier?: 'auto'|'default'|'flex'|null;
+    //     system_fingerprint?: string;
+    //     usage?: CompletionsAPI.CompletionUsage;
+    //   }
+    const { choices, done } = initializeCompletionChoices(chunk.choices);
+    return {
+        initMessage: {
+            id: chunk.id,
+            choices,
+            created: chunk.created,
+            model: chunk.model,
+            object: "chat.completion",
+            service_tier: chunk.service_tier,
+            system_fingerprint: chunk.system_fingerprint,
+            usage: chunk.usage ?? undefined,
+        },
+        done,
+    };
+}
+function updateCompletion(completion, chunk) {
+    //   export interface ChatCompletionChunk {
+    //     id: string;
+    //     choices: Array<ChatCompletionChunk.Choice>;
+    //     created: number;
+    //     model: string;
+    //     object: 'chat.completion.chunk';
+    //     service_tier?: 'auto' | 'default' | 'flex' | null;
+    //     system_fingerprint?: string;
+    //     usage?: CompletionsAPI.CompletionUsage | null;
+    //   }
+    //
+    // ->
+    //
+    //   export interface ChatCompletion {
+    //     id: string;
+    //     choices: Array<ChatCompletion.Choice>;
+    //     created: number;
+    //     model: string;
+    //     object: 'chat.completion';
+    //     service_tier?: 'auto'|'default'|'flex'|null;
+    //     system_fingerprint?: string;
+    //     usage?: CompletionsAPI.CompletionUsage;
+    //   }
+    (0, assert_1.strict)(completion.id === chunk.id);
+    (0, assert_1.strict)(completion.model === chunk.model);
+    completion.service_tier = completion.service_tier || chunk.service_tier;
+    completion.system_fingerprint =
+        completion.system_fingerprint || chunk.system_fingerprint;
+    completion.usage = completion.usage || chunk.usage || undefined;
+    return updateCompletionChoices(completion.choices, chunk.choices);
+}
+class OpenAILLMStreaming {
+    constructor(apiKey, apiUrl, model) {
+        this.openai = new openai_1.OpenAI({
+            apiKey,
+            baseURL: apiUrl,
+            dangerouslyAllowBrowser: true,
+        });
+        this.model = model || "gpt-4o-mini";
+    }
+    setModel(model) {
+        this.model = model;
+    }
+    getModel() {
+        return this.model;
+    }
+    getUrl() {
+        return this.openai.baseURL;
+    }
+    async getConversationResponse(messages, tools, onMessage) {
+        const chunks = await this.openai.chat.completions.create({
+            model: this.model,
+            messages,
+            tools,
+            stream: true,
+        });
+        // Check the type casting above
+        if (!chunks.iterator) {
+            throw "not a stream";
+        }
+        let aggregatedMessage;
+        let done = false;
+        for await (const chunk of chunks) {
+            logger.debug(`[stream] chunk: ${JSON.stringify(chunk)}`);
+            (0, assert_1.strict)(!done);
+            if (chunk.object !== "chat.completion.chunk") {
+                // logger.warn("[stream]: unexpected message");
+                continue;
+            }
+            done = (() => {
+                if (!aggregatedMessage) {
+                    logger.debug(`[stream] first}`);
+                    const { initMessage, done } = initializeCompletion(chunk);
+                    aggregatedMessage = initMessage;
+                    return done;
+                }
+                else {
+                    return updateCompletion(aggregatedMessage, chunk);
+                }
+            })();
+            if (onMessage) {
+                // Inform the call of a message fragment.  Note that even if there is
+                // no content, we must call `onMessage` once `done` is true.
+                const delta = chunk.choices[0].delta;
+                if (delta.content) {
+                    await onMessage(delta.content, done);
+                }
+                else if (done) {
+                    await onMessage("", true);
+                }
+            }
+        }
+        logger.debug(`[stream] final message: ${JSON.stringify(aggregatedMessage)}`);
+        (0, assert_1.strict)(done);
+        (0, assert_1.strict)(aggregatedMessage);
+        return aggregatedMessage;
+    }
+}
+exports.OpenAILLMStreaming = OpenAILLMStreaming;

package/dist/options.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.llmUrl = exports.llmApiKey = exports.approveToolsUpTo = exports.approveTools = exports.oneShot = exports.llmModel = exports.systemPromptFile = exports.imageFile = exports.promptFile = void 0;
+exports.secretOption = secretOption;
+const cmd_ts_1 = require("cmd-ts");
+const agentUtils_1 = require("./agentUtils");
+/// Prevents env content from being displayed in the help text.
+function secretOption({ long, short, env, description, }) {
+    if (env) {
+        return (0, cmd_ts_1.option)({
+            type: (0, cmd_ts_1.optional)(cmd_ts_1.string),
+            long,
+            short,
+            description: `${description} [env: ${env}]`,
+            defaultValue: () => process.env[env],
+            defaultValueIsSerializable: false, // hides the value from --help
+        });
+    }
+    return (0, cmd_ts_1.option)({
+        type: (0, cmd_ts_1.optional)(cmd_ts_1.string),
+        long,
+        short,
+        description: `${description} (can also be set via ${env} env var)`,
+    });
+}
+exports.promptFile = (0, cmd_ts_1.option)({
+    type: (0, cmd_ts_1.optional)(cmd_ts_1.string),
+    long: "prompt",
+    short: "p",
+    description: "File containing user's first prompt to LLM",
+});
+exports.imageFile = (0, cmd_ts_1.option)({
+    type: (0, cmd_ts_1.optional)(cmd_ts_1.string),
+    long: "image",
+    short: "i",
+    description: "File containing image input",
+});
+exports.systemPromptFile = (0, cmd_ts_1.option)({
+    type: (0, cmd_ts_1.optional)(cmd_ts_1.string),
+    long: "sysprompt",
+    short: "s",
+    description: "File containing system prompt",
+});
+exports.llmModel = (0, cmd_ts_1.option)({
+    type: (0, cmd_ts_1.optional)(cmd_ts_1.string),
+    long: "model",
+    short: "m",
+    description: "LLM model",
+    env: "LLM_MODEL",
+});
+exports.oneShot = (0, cmd_ts_1.flag)({
+    type: cmd_ts_1.boolean,
+    long: "one-shot",
+    short: "1",
+    description: "Exit after first reply (implies --approve-tools)",
+});
+exports.approveTools = (0, cmd_ts_1.flag)({
+    type: cmd_ts_1.boolean,
+    long: "approve-tools",
+    short: "y",
+    description: "Automatically approve all tool calls",
+});
+exports.approveToolsUpTo = (0, cmd_ts_1.option)({
+    type: (0, cmd_ts_1.optional)(cmd_ts_1.number),
+    long: "approve-tools-up-to",
+    description: "Automatically approve all tool calls up to some number",
+});
+exports.llmApiKey = secretOption({
+    long: "llm-api-key",
+    description: "API Key for LLM provider",
+    env: "LLM_API_KEY",
+});
+exports.llmUrl = (0, cmd_ts_1.option)({
+    type: cmd_ts_1.string,
+    long: "llm-url",
+    description: "LLM provider URL (OpenAI compatible)",
+    env: "LLM_URL",
+    defaultValue: () => agentUtils_1.DEFAULT_LLM_URL,
+});

package/dist/prompt.js

@@ -0,0 +1,83 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Prompt = void 0;
+exports.parsePrompt = parsePrompt;
+const readline_1 = __importDefault(require("readline"));
+const DEFAULT_PROMPT = "USER: ";
+class Prompt {
+    constructor() {
+        this.prompt = readline_1.default.createInterface({
+            input: process.stdin,
+            output: process.stdout,
+            prompt: DEFAULT_PROMPT,
+        });
+        this.prompt.on("line", (line) => {
+            this.line = line;
+            this.resolve();
+        });
+        this.prompt.on("close", () => {
+            this.line = undefined;
+            this.resolve();
+        });
+    }
+    async run(prompt) {
+        // Clear any line
+        this.line = "";
+        return new Promise((r) => {
+            this.online = r;
+            if (prompt) {
+                this.prompt.setPrompt(prompt);
+            }
+            this.prompt.prompt();
+            if (prompt) {
+                this.prompt.setPrompt(DEFAULT_PROMPT);
+            }
+        });
+    }
+    shutdown() {
+        this.prompt.close();
+    }
+    resolve() {
+        if (this.online) {
+            this.online(this.line);
+        }
+        this.online = undefined;
+    }
+}
+exports.Prompt = Prompt;
+/**
+ * Support prompts:
+ *  - some text                (msg: some text, cmds: undefined)
+ *  - :i image.png some text   (msg: some text, cmds: ["i", "image.png"])
+ *  - :i image.png             (msg: undefined, cmds: ["i", "image.png"])
+ *  - :l                       (msg: undefined, cmds: ["l"])
+ *  - :e toolName ..           (msg: undefined, cmds: ["e", "toolName", ...])
+ *  - :ea toolName ..          (msg: undefined, cmds: ["ea", "toolName", ...])
+ */
+function parsePrompt(prompt) {
+    prompt = prompt.trim();
+    let msg = undefined;
+    let cmds = undefined;
+    if (prompt.startsWith(":") || prompt.startsWith("/")) {
+        cmds = prompt.split(" ");
+        cmds[0] = cmds[0].slice(1);
+        if (cmds[0] == "i") {
+            // :i is special as it may have a trailing message
+            const fileDelim = prompt.indexOf(" ", 3);
+            if (fileDelim < 0) {
+                cmds = [cmds[0], prompt.slice(3)];
+            }
+            else {
+                msg = prompt.slice(fileDelim + 1);
+                cmds = [cmds[0], prompt.slice(3, fileDelim)];
+            }
+        }
+    }
+    else {
+        msg = prompt;
+    }
+    return { msg, cmds };
+}