@travisennis/acai 0.0.1

package/source/messages.ts

@@ -0,0 +1,360 @@
+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 {
+  type AssistantModelMessage,
+  generateText,
+  type ImagePart, // Added ImagePart
+  type ModelMessage,
+  type TextPart,
+  type ToolModelMessage,
+  type UserModelMessage,
+} from "ai";
+import type { ModelManager } from "./models/manager.ts";
+import type { TokenTracker } from "./token-tracker.ts";
+
+// Define a type for the items that can be passed in the first argument
+export type UserMessageContentItem = string | ImagePart;
+
+export function createUserMessage(
+  contentItems: UserMessageContentItem[],
+  prompt?: string,
+): UserModelMessage {
+  const messageParts: (TextPart | ImagePart)[] = [];
+
+  // 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: string): AssistantModelMessage {
+  return {
+    role: "assistant",
+    content: [
+      {
+        type: "text",
+        text: content,
+      },
+    ],
+  };
+}
+
+/**
+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[];
+};
+
+type RawMessageHistory = Omit<
+  SavedMessageHistory,
+  "createdAt" | "updatedAt"
+> & {
+  createdAt?: string;
+  updatedAt?: string;
+};
+
+interface MessageHistoryEvents {
+  "update-title": [string];
+  "clear-history": [];
+}
+
+export class MessageHistory extends EventEmitter<MessageHistoryEvents> {
+  private history: ModelMessage[];
+  private title: string;
+  private createdAt: Date;
+  private updatedAt: Date;
+  private stateDir: string;
+  private modelManager: ModelManager;
+  private tokenTracker: TokenTracker;
+
+  constructor({
+    stateDir,
+    modelManager,
+    tokenTracker,
+  }: {
+    stateDir: string;
+    modelManager: ModelManager;
+    tokenTracker: TokenTracker;
+  }) {
+    super();
+    this.history = [];
+    this.title = "";
+    this.createdAt = new Date();
+    this.updatedAt = new Date();
+    this.stateDir = stateDir;
+    this.modelManager = modelManager;
+    this.tokenTracker = tokenTracker;
+  }
+
+  private validMessage(msg: ModelMessage) {
+    // 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: string): void;
+  appendUserMessage(msg: UserModelMessage): void;
+  appendUserMessage(msg: string | UserModelMessage) {
+    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) as TextPart;
+      if (textPart?.text && textPart.text.trim() !== "") {
+        this.generateTitle(textPart.text);
+      }
+      this.createdAt = now;
+    }
+    this.updatedAt = now;
+    this.history.push(msgObj);
+  }
+
+  appendAssistantMessage(msg: string): void;
+  appendAssistantMessage(msg: AssistantModelMessage): void;
+  appendAssistantMessage(msg: string | AssistantModelMessage) {
+    this.updatedAt = new Date();
+    const msgObj = isString(msg) ? createAssistantMessage(msg) : msg;
+    this.history.push(msgObj);
+  }
+
+  appendResponseMessages(responseMessages: ResponseMessage[]) {
+    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: SavedMessageHistory = {
+      title: this.title,
+      createdAt: this.createdAt,
+      updatedAt: this.updatedAt,
+      messages: this.history,
+    };
+
+    await writeFile(filePath, JSON.stringify(output, null, 2));
+  }
+
+  private async generateTitle(message: string) {
+    // 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(): UserModelMessage | undefined {
+    const firstUser = this.get().find(
+      (msg): msg is UserModelMessage => msg.role === "user",
+    );
+    return firstUser;
+  }
+
+  static async load(
+    stateDir: string,
+    count = 10, // Add count parameter with default
+  ): Promise<SavedMessageHistory[]> {
+    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) as RawMessageHistory;
+          const result: SavedMessageHistory =
+            parsed as unknown as SavedMessageHistory;
+          // 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 is SavedMessageHistory => 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 as NodeJS.ErrnoException).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: SavedMessageHistory): void {
+    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: ModelMessage[],
+): ModelMessage[] {
+  const result: ModelMessage[] = [];
+  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] as any, // #FIXME figure out what type this should be
+        };
+        continue;
+      }
+      case "assistant": {
+        result.push(message);
+        continue;
+      }
+      default:
+        continue;
+    }
+  }
+  return result;
+}

package/source/middleware/audit-message.ts

@@ -0,0 +1,133 @@
+import { mkdir, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import type {
+  LanguageModelV2Middleware,
+  LanguageModelV2Prompt,
+  LanguageModelV2StreamPart,
+  LanguageModelV2TextPart,
+} from "@ai-sdk/provider";
+import type { LanguageModelUsage } from "ai";
+
+interface AuditRecord {
+  model: string;
+  app: string;
+  messages: LanguageModelV2Prompt;
+  usage: LanguageModelUsage;
+  timestamp: number;
+}
+
+/**
+ * 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: string,
+  filePath: string,
+  content: AuditRecord,
+): Promise<void> => {
+  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",
+}: {
+  filePath: string;
+  app: string;
+}) => {
+  const middleware: LanguageModelV2Middleware = {
+    wrapGenerate: async ({ doGenerate, params, model }) => {
+      const result = await doGenerate();
+
+      const msg: AuditRecord = {
+        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 as any).text,
+            } as LanguageModelV2TextPart,
+          ],
+        }),
+        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: LanguageModelUsage = {
+        inputTokens: 0,
+        outputTokens: 0,
+        totalTokens: 0,
+      };
+
+      const transformStream = new TransformStream<
+        LanguageModelV2StreamPart,
+        LanguageModelV2StreamPart
+      >({
+        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: AuditRecord = {
+            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/source/middleware/index.ts

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

package/source/middleware/rate-limit.ts

@@ -0,0 +1,24 @@
+import type { LanguageModelV2Middleware } from "@ai-sdk/provider";
+import pThrottle from "p-throttle";
+
+export const createRateLimitMiddleware = ({
+  requestsPerMinute,
+}: {
+  requestsPerMinute: number;
+}): LanguageModelV2Middleware => {
+  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/source/models/ai-config.ts

@@ -0,0 +1,109 @@
+import type { SharedV2ProviderMetadata } from "@ai-sdk/provider";
+import type { ModelMetadata } from "./providers.ts";
+
+type Effort = "none" | "low" | "medium" | "high";
+
+const THINKING_TIERS: {
+  pattern: RegExp;
+  budget: number;
+  effort: Effort;
+}[] = [
+  {
+    pattern:
+      /\b(ultrathink|think super hard|think really hard|think intensely)\b/i,
+    budget: 31999,
+    effort: "high",
+  },
+  {
+    pattern: /\b(megathink|think (very )?hard|think (a lot|more|about it))\b/i,
+    budget: 10000,
+    effort: "medium",
+  },
+  {
+    pattern: /\bthink\b/i, // Catch-all for standalone "think"
+    budget: 4000,
+    effort: "low",
+  },
+];
+
+function calculateThinkingLevel(userInput: string): {
+  tokenBudget: number;
+  effort: Effort;
+} {
+  let tokenBudget = 0; // Default
+  let effort: Effort = "none";
+  for (const tier of THINKING_TIERS) {
+    if (tier.pattern.test(userInput)) {
+      tokenBudget = tier.budget;
+      effort = tier.effort;
+      break; // Use highest priority match
+    }
+  }
+  return { tokenBudget, effort };
+}
+
+export class AiConfig {
+  private modelMetadata: ModelMetadata;
+  private prompt: string;
+  constructor({
+    modelMetadata,
+    prompt,
+  }: { modelMetadata: ModelMetadata; prompt: string }) {
+    this.modelMetadata = modelMetadata;
+    this.prompt = prompt;
+  }
+
+  getMaxTokens() {
+    const modelConfig = this.modelMetadata;
+    const thinkingLevel = calculateThinkingLevel(this.prompt);
+    const maxTokens =
+      modelConfig.provider === "anthropic" && modelConfig.supportsReasoning
+        ? modelConfig.maxOutputTokens - thinkingLevel.tokenBudget
+        : modelConfig.maxOutputTokens;
+    return maxTokens;
+  }
+
+  getProviderOptions(): SharedV2ProviderMetadata {
+    const modelConfig = this.modelMetadata;
+    const thinkingLevel = calculateThinkingLevel(this.prompt);
+
+    if (modelConfig.supportsReasoning && thinkingLevel.effort !== "none") {
+      switch (modelConfig.provider) {
+        case "anthropic":
+          return {
+            anthropic: {
+              thinking: {
+                type: "enabled",
+                budgetTokens: thinkingLevel.tokenBudget,
+              },
+            },
+          };
+        case "openai":
+          return { openai: { reasoningEffort: thinkingLevel.effort } };
+        case "google": {
+          return {
+            google: {
+              thinkingConfig: {
+                thinkingBudget: thinkingLevel.tokenBudget,
+              },
+            },
+          };
+        }
+        case "openrouter": {
+          return {
+            openrouter: {
+              reasoning: {
+                enabled: true,
+                effort: thinkingLevel.effort,
+              },
+            },
+          };
+        }
+        default:
+          return {};
+      }
+    }
+    // If supportsReasoning is false, or no provider case matched
+    return {};
+  }
+}