@travisennis/acai 0.0.1

package/dist/source/mentions.js

@@ -0,0 +1,182 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { isString } from "@travisennis/stdlib/typeguards";
+import { formatFile, formatUrl } from "./formatting.js";
+import { readUrl } from "./tools/web-fetch.js";
+import { executeCommand } from "./utils/process.js";
+// Helper function to recursively read all files in a directory
+async function readDirectoryRecursive(dirPath, format) {
+    const allContents = [];
+    async function readDir(currentPath, relativePath = "") {
+        const entries = await fs.readdir(currentPath, { withFileTypes: true });
+        for (const entry of entries) {
+            const fullPath = path.join(currentPath, entry.name);
+            const relativeFilePath = path.join(relativePath, entry.name);
+            if (entry.isDirectory()) {
+                await readDir(fullPath, relativeFilePath);
+            }
+            else if (entry.isFile()) {
+                try {
+                    const fileContents = await fs.readFile(fullPath, "utf8");
+                    allContents.push(formatFile(relativeFilePath, fileContents, format));
+                }
+                catch (error) {
+                    allContents.push(`Error reading file ${relativeFilePath}: ${error instanceof Error ? error.message : "Unknown error"}`);
+                }
+            }
+        }
+    }
+    await readDir(dirPath);
+    if (allContents.length === 0) {
+        return `Directory ${path.basename(dirPath)} is empty or contains no readable files.`;
+    }
+    return allContents.join("\n\n");
+}
+// Returns the formatted string or an error message string
+async function processFileCommand(context) {
+    const { baseDir, match } = context;
+    const filePath = match.trim();
+    const format = context.model.promptFormat;
+    try {
+        // Resolve paths to absolute to prevent traversal issues
+        const resolvedBaseDir = path.resolve(baseDir);
+        const resolvedFilePath = path.resolve(resolvedBaseDir, filePath);
+        // Security Check: Ensure the resolved path is still within the base directory
+        if (!resolvedFilePath.startsWith(resolvedBaseDir + path.sep)) {
+            return `Error: Access denied. Attempted to read file outside the allowed directory: ${filePath}`;
+        }
+        // Check if path exists
+        const stats = await fs.stat(resolvedFilePath);
+        // If it's a directory, read all files recursively
+        if (stats.isDirectory()) {
+            return await readDirectoryRecursive(resolvedFilePath, format);
+        }
+        // If it's a file, process as before
+        if (stats.isFile()) {
+            const fileContents = await fs.readFile(resolvedFilePath, "utf8");
+            return formatFile(filePath, fileContents, format);
+        }
+        return `Error: ${filePath} is neither a regular file nor directory.`;
+    }
+    catch (error) {
+        // Handle both ENOENT (file not found) and permission errors
+        if (error && typeof error === "object" && "code" in error) {
+            if (error.code === "ENOENT") {
+                return `Error: File or directory not found: ${filePath}\nPlease check that the path is correct and exists.`;
+            }
+            if (error.code === "EACCES") {
+                return `Error: Permission denied accessing: ${filePath}`;
+            }
+        }
+        if (error instanceof Error) {
+            return `Error accessing ${filePath}: ${error.message}`;
+        }
+        // Fallback for unknown error types
+        return `Error accessing ${filePath}: An unknown error occurred.`;
+    }
+}
+async function processShellCommand(command) {
+    try {
+        const { stdout, stderr, code } = await executeCommand(command, {
+            shell: true,
+        });
+        if (code === 0) {
+            return stdout;
+        }
+        return `Error executing command: ${command}\n${stderr}`;
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            return `Error executing command ${command}: ${error.message}`;
+        }
+        return `Error executing command ${command}: An unknown error occurred.`;
+    }
+}
+// Returns the formatted string or an error message string
+async function processUrlCommand(context) {
+    const { match } = context;
+    const urlPath = match;
+    try {
+        return Object.assign(await readUrl(urlPath), { source: urlPath });
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            return {
+                contentType: "text/plain",
+                data: `Url: ${urlPath} Status: Error fetching URL: ${error.message}`,
+                source: urlPath,
+            };
+        }
+        // Fallback for unknown error types
+        return {
+            contentType: "text/plain",
+            data: `Url: ${urlPath} Status: Error fetching URL: An unknown error occurred.`,
+            source: urlPath,
+        };
+    }
+}
+export async function processPrompt(message, { baseDir, model }) {
+    const fileRegex = /@([^\s@]+(?:\.[\w\d]+))/g;
+    const urlRegex = /@(https?:\/\/[^\s]+)/g;
+    const shellRegex = /!`([^`]+)`/g;
+    // Collect all matches for files and urls
+    const fileMatches = Array.from(message.matchAll(fileRegex));
+    const urlMatches = Array.from(message.matchAll(urlRegex));
+    const shellMatches = Array.from(message.matchAll(shellRegex));
+    const mentionProcessingPromises = [];
+    // Process file references - collect promises
+    for (const match of fileMatches) {
+        const firstMatch = match[1];
+        if (firstMatch) {
+            const context = {
+                model,
+                baseDir,
+                match: firstMatch,
+            };
+            mentionProcessingPromises.push(processFileCommand(context));
+        }
+    }
+    // Process url references - collect promises
+    for (const match of urlMatches) {
+        const firstMatch = match[1];
+        if (firstMatch) {
+            const context = {
+                model,
+                baseDir, // baseDir is not used by processUrlCommand but kept for consistency
+                match: firstMatch,
+            };
+            mentionProcessingPromises.push(processUrlCommand(context));
+        }
+    }
+    let processedMessage = message;
+    // Process shell commands
+    for (const match of shellMatches) {
+        const command = match[1];
+        if (command) {
+            const output = await processShellCommand(command);
+            processedMessage = processedMessage.replace(match[0], output);
+        }
+    }
+    // Wait for all mentions to be processed
+    const mentionResults = await Promise.all(mentionProcessingPromises);
+    const context = [];
+    for (const mention of mentionResults) {
+        if (isString(mention)) {
+            context.push(mention);
+        }
+        else if (mention.data.startsWith("data")) {
+            context.push({
+                type: "image",
+                mediaType: mention.contentType,
+                image: mention.data,
+            });
+        }
+        else {
+            context.push(formatUrl(mention.source, mention.data.trim(), model.promptFormat));
+        }
+    }
+    return {
+        message: processedMessage,
+        context,
+    };
+}

package/dist/source/messages.d.ts

@@ -0,0 +1,69 @@
+import EventEmitter from "node:events";
+import { type AssistantModelMessage, type ImagePart, // Added ImagePart
+type ModelMessage, type ToolModelMessage, type UserModelMessage } from "ai";
+import type { ModelManager } from "./models/manager.ts";
+import type { TokenTracker } from "./token-tracker.ts";
+export type UserMessageContentItem = string | ImagePart;
+export declare function createUserMessage(contentItems: UserMessageContentItem[], prompt?: string): UserModelMessage;
+export declare function createAssistantMessage(content: string): AssistantModelMessage;
+/**
+A message that was generated during the generation process.
+It can be either an assistant message or a tool message.
+ */
+type ResponseMessage = AssistantModelMessage | ToolModelMessage;
+export type SavedMessageHistory = {
+    title: string;
+    createdAt: Date;
+    updatedAt: Date;
+    messages: ModelMessage[];
+};
+interface MessageHistoryEvents {
+    "update-title": [string];
+    "clear-history": [];
+}
+export declare class MessageHistory extends EventEmitter<MessageHistoryEvents> {
+    private history;
+    private title;
+    private createdAt;
+    private updatedAt;
+    private stateDir;
+    private modelManager;
+    private tokenTracker;
+    constructor({ stateDir, modelManager, tokenTracker, }: {
+        stateDir: string;
+        modelManager: ModelManager;
+        tokenTracker: TokenTracker;
+    });
+    private validMessage;
+    get(): ModelMessage[];
+    clear(): void;
+    appendUserMessage(msg: string): void;
+    appendUserMessage(msg: UserModelMessage): void;
+    appendAssistantMessage(msg: string): void;
+    appendAssistantMessage(msg: AssistantModelMessage): void;
+    appendResponseMessages(responseMessages: ResponseMessage[]): void;
+    isEmpty(): boolean;
+    save(): Promise<void>;
+    private generateTitle;
+    getFirstUserMessage(): UserModelMessage | undefined;
+    static load(stateDir: string, count?: number): Promise<SavedMessageHistory[]>;
+    restore(savedHistory: SavedMessageHistory): void;
+}
+/**
+ * Normalizes an array of messages for API consumption by:
+ * 1. Filtering out progress-type messages
+ * 2. Processing user and assistant messages
+ * 3. Handling tool results by either:
+ *    - Adding them as new messages if they're the first tool result
+ *    - Adding them as new messages if the previous message wasn't a tool result
+ *    - Merging them with the previous message if it was also a tool result
+ *
+ * This consolidation of sequential tool results into a single message
+ * ensures proper formatting for API consumption while maintaining the
+ * logical flow of the conversation.
+ *
+ * @param messages - Array of messages to normalize
+ * @returns Normalized array of user and assistant messages ready for API
+ */
+export declare function normalizeMessagesForApi(messages: ModelMessage[]): ModelMessage[];
+export {};

package/dist/source/messages.js

@@ -0,0 +1,261 @@
+import EventEmitter from "node:events";
+import { readdir, readFile, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { isString } from "@travisennis/stdlib/typeguards";
+import { generateText, } from "ai";
+export function createUserMessage(contentItems, prompt) {
+    const messageParts = [];
+    // Process content items (images and pre-defined texts)
+    for (const item of contentItems) {
+        if (typeof item === "string") {
+            if (item.trim().length > 0) {
+                messageParts.push({ type: "text", text: item });
+            }
+        }
+        else if (item.type === "image") {
+            messageParts.push(item);
+        }
+    }
+    // Add the main prompt text if provided
+    if (prompt && prompt.trim().length > 0) {
+        messageParts.push({ type: "text", text: prompt });
+    }
+    return {
+        role: "user",
+        content: messageParts,
+    };
+}
+export function createAssistantMessage(content) {
+    return {
+        role: "assistant",
+        content: [
+            {
+                type: "text",
+                text: content,
+            },
+        ],
+    };
+}
+export class MessageHistory extends EventEmitter {
+    history;
+    title;
+    createdAt;
+    updatedAt;
+    stateDir;
+    modelManager;
+    tokenTracker;
+    constructor({ stateDir, modelManager, tokenTracker, }) {
+        super();
+        this.history = [];
+        this.title = "";
+        this.createdAt = new Date();
+        this.updatedAt = new Date();
+        this.stateDir = stateDir;
+        this.modelManager = modelManager;
+        this.tokenTracker = tokenTracker;
+    }
+    validMessage(msg) {
+        // Filter out messages with empty content arrays
+        if (Array.isArray(msg.content) && msg.content.length === 0) {
+            return false;
+        }
+        // Filter out assistant messages with empty text fields
+        if (msg.role === "assistant" &&
+            Array.isArray(msg.content) &&
+            msg.content.length === 1 &&
+            msg.content[0]?.type === "text" &&
+            msg.content[0]?.text === "") {
+            return false;
+        }
+        return true;
+    }
+    get() {
+        return [...this.history].filter(this.validMessage);
+    }
+    clear() {
+        this.history.length = 0;
+        this.emit("clear-history");
+    }
+    appendUserMessage(msg) {
+        const now = new Date();
+        const msgObj = isString(msg) ? createUserMessage([], msg) : msg;
+        if (this.history.length === 0 &&
+            msgObj.content &&
+            msgObj.content.length > 0) {
+            const textPart = msgObj.content.at(-1);
+            if (textPart?.text && textPart.text.trim() !== "") {
+                this.generateTitle(textPart.text);
+            }
+            this.createdAt = now;
+        }
+        this.updatedAt = now;
+        this.history.push(msgObj);
+    }
+    appendAssistantMessage(msg) {
+        this.updatedAt = new Date();
+        const msgObj = isString(msg) ? createAssistantMessage(msg) : msg;
+        this.history.push(msgObj);
+    }
+    appendResponseMessages(responseMessages) {
+        this.updatedAt = new Date();
+        // Filter out messages with empty content arrays
+        const validMessages = responseMessages.filter(this.validMessage);
+        this.history.push(...validMessages);
+    }
+    isEmpty() {
+        return this.history.length === 0;
+    }
+    async save() {
+        const msgHistoryDir = this.stateDir;
+        const timestamp = new Date().toISOString().replace(/:/g, "-");
+        const fileName = `message-history-${timestamp}.json`;
+        const filePath = join(msgHistoryDir, fileName);
+        const output = {
+            title: this.title,
+            createdAt: this.createdAt,
+            updatedAt: this.updatedAt,
+            messages: this.history,
+        };
+        await writeFile(filePath, JSON.stringify(output, null, 2));
+    }
+    async generateTitle(message) {
+        // Skip title generation if message is empty
+        if (!message || message.trim() === "") {
+            return;
+        }
+        const app = "title-conversation";
+        const systemPrompt = "You are an assistant who task is to analyze messages to generate a conversation topic that can be used as a conversation title. For each message, generate a 4-7 word title that captures the topic. Return only the title with no other text.\n\nExamples:\nMessage:\nHow do I implement authentication in my Express app?\nTitle: Express Authentication Implementation\n\nMessage:\nCan you help me debug this React component that isn't rendering correctly?\nTitle:React Component Rendering Debug";
+        try {
+            const { text, usage } = await generateText({
+                model: this.modelManager.getModel(app),
+                system: systemPrompt,
+                prompt: `Request:\n${message}\nTitle:`,
+            });
+            this.tokenTracker.trackUsage(app, usage);
+            if (text && text.split(" ").length < 10) {
+                this.title = text;
+                this.emit("update-title", this.title);
+            }
+        }
+        catch (error) {
+            console.error(error);
+        }
+    }
+    getFirstUserMessage() {
+        const firstUser = this.get().find((msg) => msg.role === "user");
+        return firstUser;
+    }
+    static async load(stateDir, count = 10) {
+        try {
+            const files = await readdir(stateDir);
+            const messageHistoryFiles = files
+                .filter((file) => file.startsWith("message-history-") && file.endsWith(".json"))
+                .sort((a, b) => {
+                // Extract timestamps and compare in reverse order (newest first)
+                const timeA = a.replace("message-history-", "").replace(".json", "");
+                const timeB = b.replace("message-history-", "").replace(".json", "");
+                return timeB.localeCompare(timeA); // Newest first
+            })
+                .slice(0, count); // Use the count parameter here
+            const fileReadPromises = messageHistoryFiles.map(async (fileName) => {
+                const filePath = join(stateDir, fileName);
+                try {
+                    const content = await readFile(filePath, "utf-8");
+                    const parsed = JSON.parse(content);
+                    const result = parsed;
+                    // Basic validation - ensure messages array exists
+                    if (parsed && Array.isArray(parsed.messages)) {
+                        // Convert date strings back to Date objects
+                        result.createdAt = new Date(parsed.createdAt ?? 0);
+                        result.updatedAt = new Date(parsed.updatedAt ?? 0);
+                        return result;
+                    }
+                }
+                catch (error) {
+                    console.error(`Error reading or parsing file ${filePath}:`, error);
+                }
+                return null; // Return null for failed reads/parses
+            });
+            const results = await Promise.all(fileReadPromises);
+            // Filter out null results (failed reads/parses)
+            //sort results by result.updatedAt which is a Date
+            return results
+                .filter((result) => result !== null)
+                .sort((a, b) => b.updatedAt.getTime() - a.updatedAt.getTime());
+        }
+        catch (error) {
+            // Handle cases where the directory might not exist or other readdir errors
+            if (error.code !== "ENOENT") {
+                console.error(`Error loading message history from ${stateDir}:`, error);
+            }
+            // Return empty array if directory doesn't exist or other read errors occur
+            return [];
+        }
+    }
+    // Method to restore state from a SavedMessageHistory object
+    restore(savedHistory) {
+        this.title = savedHistory.title;
+        // Ensure dates are Date objects, though load should handle this
+        this.createdAt =
+            typeof savedHistory.createdAt === "string"
+                ? new Date(savedHistory.createdAt)
+                : savedHistory.createdAt;
+        this.updatedAt =
+            typeof savedHistory.updatedAt === "string"
+                ? new Date(savedHistory.updatedAt)
+                : savedHistory.updatedAt;
+        this.history = [...savedHistory.messages]; // Use the correct internal property name and create a copy
+    }
+}
+/**
+ * Normalizes an array of messages for API consumption by:
+ * 1. Filtering out progress-type messages
+ * 2. Processing user and assistant messages
+ * 3. Handling tool results by either:
+ *    - Adding them as new messages if they're the first tool result
+ *    - Adding them as new messages if the previous message wasn't a tool result
+ *    - Merging them with the previous message if it was also a tool result
+ *
+ * This consolidation of sequential tool results into a single message
+ * ensures proper formatting for API consumption while maintaining the
+ * logical flow of the conversation.
+ *
+ * @param messages - Array of messages to normalize
+ * @returns Normalized array of user and assistant messages ready for API
+ */
+export function normalizeMessagesForApi(messages) {
+    const result = [];
+    for (const message of messages) {
+        switch (message.role) {
+            case "user": {
+                result.push(message);
+                continue;
+            }
+            case "tool": {
+                // If the last message is not a tool result, add it to the result
+                const lastMessage = result.at(-1);
+                if (!lastMessage ||
+                    lastMessage.role === "assistant" ||
+                    !Array.isArray(lastMessage.content) ||
+                    lastMessage.content[0]?.type !== "tool-result") {
+                    result.push(message);
+                    continue;
+                }
+                // Otherwise, merge the current message with the last message
+                result[result.indexOf(lastMessage)] = {
+                    ...lastMessage,
+                    // biome-ignore lint/suspicious/noExplicitAny: can't figure out type
+                    content: [...lastMessage.content, ...message.content], // #FIXME figure out what type this should be
+                };
+                continue;
+            }
+            case "assistant": {
+                result.push(message);
+                continue;
+            }
+            default:
+                continue;
+        }
+    }
+    return result;
+}

package/dist/source/middleware/audit-message.d.ts

@@ -0,0 +1,5 @@
+import type { LanguageModelV2Middleware } from "@ai-sdk/provider";
+export declare const auditMessage: ({ filePath, app, }: {
+    filePath: string;
+    app: string;
+}) => LanguageModelV2Middleware;

package/dist/source/middleware/audit-message.js

@@ -0,0 +1,95 @@
+import { mkdir, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+/**
+ * Writes an audit record to the specified file, overwriting any existing content.
+ * Ensures the directory exists before writing.
+ *
+ * @param filePath - The path to the file where the audit record will be saved.
+ * @param content - The audit record object to write.
+ */
+const writeAuditRecord = async (app, filePath, content) => {
+    try {
+        const now = new Date();
+        const path = join(filePath, `${now.toISOString()}-${app}-message.json`);
+        // Ensure directory exists
+        await mkdir(dirname(path), { recursive: true });
+        await writeFile(path, `${JSON.stringify(content, null, 2)}`);
+    }
+    catch (error) {
+        console.error("Error writing audit file:", error);
+        throw error;
+    }
+};
+export const auditMessage = ({ filePath = "messages", app = "default", }) => {
+    const middleware = {
+        wrapGenerate: async ({ doGenerate, params, model }) => {
+            const result = await doGenerate();
+            const msg = {
+                model: model.modelId,
+                app,
+                messages: [...params.prompt].concat({
+                    role: "assistant",
+                    content: [
+                        {
+                            type: "text",
+                            // biome-ignore lint/suspicious/noExplicitAny: work-around on type issue
+                            text: result.text,
+                        },
+                    ],
+                }),
+                usage: result.usage,
+                timestamp: Date.now(),
+            };
+            await writeAuditRecord(app, filePath, msg);
+            return result;
+        },
+        wrapStream: async ({ doStream, params, model }) => {
+            const { stream, ...rest } = await doStream();
+            let generatedText = "";
+            let usage = {
+                inputTokens: 0,
+                outputTokens: 0,
+                totalTokens: 0,
+            };
+            const transformStream = new TransformStream({
+                transform(chunk, controller) {
+                    if (chunk.type === "text-delta") {
+                        generatedText += chunk.delta;
+                    }
+                    if (chunk.type === "finish") {
+                        usage = chunk.usage;
+                    }
+                    controller.enqueue(chunk);
+                },
+                async flush() {
+                    const msg = {
+                        model: model.modelId,
+                        app,
+                        messages: generatedText
+                            ? [
+                                ...params.prompt,
+                                {
+                                    role: "assistant",
+                                    content: [
+                                        {
+                                            type: "text",
+                                            text: generatedText,
+                                        },
+                                    ],
+                                },
+                            ]
+                            : [...params.prompt],
+                        usage,
+                        timestamp: Date.now(),
+                    };
+                    await writeAuditRecord(app, filePath, msg);
+                },
+            });
+            return {
+                stream: stream.pipeThrough(transformStream),
+                ...rest,
+            };
+        },
+    };
+    return middleware;
+};

package/dist/source/middleware/index.d.ts

@@ -0,0 +1,2 @@
+export { auditMessage } from "./audit-message.ts";
+export { createRateLimitMiddleware } from "./rate-limit.ts";

package/dist/source/middleware/index.js

@@ -0,0 +1,2 @@
+export { auditMessage } from "./audit-message.js";
+export { createRateLimitMiddleware } from "./rate-limit.js";

package/dist/source/middleware/rate-limit.d.ts

@@ -0,0 +1,4 @@
+import type { LanguageModelV2Middleware } from "@ai-sdk/provider";
+export declare const createRateLimitMiddleware: ({ requestsPerMinute, }: {
+    requestsPerMinute: number;
+}) => LanguageModelV2Middleware;

package/dist/source/middleware/rate-limit.js

@@ -0,0 +1,17 @@
+import pThrottle from "p-throttle";
+export const createRateLimitMiddleware = ({ requestsPerMinute, }) => {
+    const throttle = pThrottle({
+        limit: requestsPerMinute,
+        interval: 60 * 1000, // 1 minute
+    });
+    return {
+        wrapGenerate: ({ doGenerate }) => {
+            const throttledGenerate = throttle(doGenerate);
+            return Promise.resolve(throttledGenerate());
+        },
+        wrapStream: ({ doStream }) => {
+            const throttledStream = throttle(doStream);
+            return throttledStream();
+        },
+    };
+};

package/dist/source/models/ai-config.d.ts

@@ -0,0 +1,12 @@
+import type { SharedV2ProviderMetadata } from "@ai-sdk/provider";
+import type { ModelMetadata } from "./providers.ts";
+export declare class AiConfig {
+    private modelMetadata;
+    private prompt;
+    constructor({ modelMetadata, prompt, }: {
+        modelMetadata: ModelMetadata;
+        prompt: string;
+    });
+    getMaxTokens(): number;
+    getProviderOptions(): SharedV2ProviderMetadata;
+}