зняы

duckai.ts

@@ -0,0 +1,475 @@
+import UserAgent from "user-agents";
+import { JSDOM } from "jsdom";
+import { RateLimitStore } from "./rate-limit-store";
+import { SharedRateLimitMonitor } from "./shared-rate-limit-monitor";
+import type {
+  ChatCompletionMessage,
+  VQDResponse,
+  DuckAIRequest,
+} from "./types";
+import { createHash } from "node:crypto";
+import { Buffer } from "node:buffer";
+
+// Rate limiting tracking with sliding window
+interface RateLimitInfo {
+  requestTimestamps: number[]; // Array of request timestamps for sliding window
+  lastRequestTime: number;
+  isLimited: boolean;
+  retryAfter?: number;
+}
+
+export class DuckAI {
+  private rateLimitInfo: RateLimitInfo = {
+    requestTimestamps: [],
+    lastRequestTime: 0,
+    isLimited: false,
+  };
+  private rateLimitStore: RateLimitStore;
+  private rateLimitMonitor: SharedRateLimitMonitor;
+
+  // Conservative rate limiting - adjust based on observed limits
+  private readonly MAX_REQUESTS_PER_MINUTE = 20;
+  private readonly WINDOW_SIZE_MS = 60 * 1000; // 1 minute
+  private readonly MIN_REQUEST_INTERVAL_MS = 1000; // 1 second between requests
+
+  constructor() {
+    this.rateLimitStore = new RateLimitStore();
+    this.rateLimitMonitor = new SharedRateLimitMonitor();
+    this.loadRateLimitFromStore();
+  }
+
+  /**
+   * Clean old timestamps outside the sliding window
+   */
+  private cleanOldTimestamps(): void {
+    const now = Date.now();
+    const cutoff = now - this.WINDOW_SIZE_MS;
+    this.rateLimitInfo.requestTimestamps =
+      this.rateLimitInfo.requestTimestamps.filter(
+        (timestamp) => timestamp > cutoff
+      );
+  }
+
+  /**
+   * Get current request count in sliding window
+   */
+  private getCurrentRequestCount(): number {
+    this.cleanOldTimestamps();
+    return this.rateLimitInfo.requestTimestamps.length;
+  }
+
+  /**
+   * Load rate limit data from shared store
+   */
+  private loadRateLimitFromStore(): void {
+    const stored = this.rateLimitStore.read();
+    if (stored) {
+      // Convert old format to new sliding window format if needed
+      const storedAny = stored as any;
+      if ("requestCount" in storedAny && "windowStart" in storedAny) {
+        // Old format - convert to new format (start fresh)
+        this.rateLimitInfo = {
+          requestTimestamps: [],
+          lastRequestTime: storedAny.lastRequestTime || 0,
+          isLimited: storedAny.isLimited || false,
+          retryAfter: storedAny.retryAfter,
+        };
+      } else {
+        // New format
+        this.rateLimitInfo = {
+          requestTimestamps: storedAny.requestTimestamps || [],
+          lastRequestTime: storedAny.lastRequestTime || 0,
+          isLimited: storedAny.isLimited || false,
+          retryAfter: storedAny.retryAfter,
+        };
+      }
+      // Clean old timestamps after loading
+      this.cleanOldTimestamps();
+    }
+  }
+
+  /**
+   * Save rate limit data to shared store
+   */
+  private saveRateLimitToStore(): void {
+    this.cleanOldTimestamps();
+    this.rateLimitStore.write({
+      requestTimestamps: this.rateLimitInfo.requestTimestamps,
+      lastRequestTime: this.rateLimitInfo.lastRequestTime,
+      isLimited: this.rateLimitInfo.isLimited,
+      retryAfter: this.rateLimitInfo.retryAfter,
+    } as any);
+  }
+
+  /**
+   * Get current rate limit status
+   */
+  getRateLimitStatus(): {
+    requestsInCurrentWindow: number;
+    maxRequestsPerMinute: number;
+    timeUntilWindowReset: number;
+    isCurrentlyLimited: boolean;
+    recommendedWaitTime: number;
+  } {
+    // Load latest data from store first
+    this.loadRateLimitFromStore();
+
+    const now = Date.now();
+    const currentRequestCount = this.getCurrentRequestCount();
+
+    // For sliding window, there's no fixed reset time
+    // The "reset" happens continuously as old requests fall out of the window
+    const oldestTimestamp = this.rateLimitInfo.requestTimestamps[0];
+    const timeUntilReset = oldestTimestamp
+      ? Math.max(0, oldestTimestamp + this.WINDOW_SIZE_MS - now)
+      : 0;
+
+    const timeSinceLastRequest = now - this.rateLimitInfo.lastRequestTime;
+    const recommendedWait = Math.max(
+      0,
+      this.MIN_REQUEST_INTERVAL_MS - timeSinceLastRequest
+    );
+
+    return {
+      requestsInCurrentWindow: currentRequestCount,
+      maxRequestsPerMinute: this.MAX_REQUESTS_PER_MINUTE,
+      timeUntilWindowReset: timeUntilReset,
+      isCurrentlyLimited: this.rateLimitInfo.isLimited,
+      recommendedWaitTime: recommendedWait,
+    };
+  }
+
+  /**
+   * Check if we should wait before making a request
+   */
+  private shouldWaitBeforeRequest(): { shouldWait: boolean; waitTime: number } {
+    // Load latest data from store first
+    this.loadRateLimitFromStore();
+
+    const now = Date.now();
+    const currentRequestCount = this.getCurrentRequestCount();
+
+    // Check if we're hitting the rate limit
+    if (currentRequestCount >= this.MAX_REQUESTS_PER_MINUTE) {
+      // Find the oldest request timestamp
+      const oldestTimestamp = this.rateLimitInfo.requestTimestamps[0];
+      if (oldestTimestamp) {
+        // Wait until the oldest request falls out of the window
+        const waitTime = oldestTimestamp + this.WINDOW_SIZE_MS - now + 100; // +100ms buffer
+        return { shouldWait: true, waitTime: Math.max(0, waitTime) };
+      }
+    }
+
+    // Check minimum interval between requests
+    const timeSinceLastRequest = now - this.rateLimitInfo.lastRequestTime;
+    if (timeSinceLastRequest < this.MIN_REQUEST_INTERVAL_MS) {
+      const waitTime = this.MIN_REQUEST_INTERVAL_MS - timeSinceLastRequest;
+      return { shouldWait: true, waitTime };
+    }
+
+    return { shouldWait: false, waitTime: 0 };
+  }
+
+  /**
+   * Wait if necessary before making a request
+   */
+  private async waitIfNeeded(): Promise<void> {
+    const { shouldWait, waitTime } = this.shouldWaitBeforeRequest();
+
+    if (shouldWait) {
+      console.log(`Rate limiting: waiting ${waitTime}ms before next request`);
+      await new Promise((resolve) => setTimeout(resolve, waitTime));
+    }
+  }
+
+  private async getEncodedVqdHash(vqdHash: string): Promise<string> {
+    const jsScript = Buffer.from(vqdHash, 'base64').toString('utf-8');
+
+    const dom = new JSDOM(
+      `<iframe id="jsa" sandbox="allow-scripts allow-same-origin" srcdoc="<!DOCTYPE html>
+<html>
+<head>
+<meta http-equiv="Content-Security-Policy"; content="default-src 'none'; script-src 'unsafe-inline'">
+</head>
+<body></body>
+</html>" style="position: absolute; left: -9999px; top: -9999px;"></iframe>`,
+      { runScripts: 'dangerously' }
+    );
+    dom.window.top.__DDG_BE_VERSION__ = 1;
+    dom.window.top.__DDG_FE_CHAT_HASH__ = 1;
+    const jsa = dom.window.top.document.querySelector('#jsa') as HTMLIFrameElement;
+    const contentDoc = jsa.contentDocument || jsa.contentWindow!.document;
+
+    const meta = contentDoc.createElement('meta');
+    meta.setAttribute('http-equiv', 'Content-Security-Policy');
+    meta.setAttribute('content', "default-src 'none'; script-src 'unsafe-inline';");
+    contentDoc.head.appendChild(meta);
+    const result = await dom.window.eval(jsScript) as {
+      client_hashes: string[];
+      [key: string]: any;
+    };
+
+    result.client_hashes[0] = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/138.0.0.0 Safari/537.36';
+    result.client_hashes = result.client_hashes.map((t) => {
+      const hash = createHash('sha256');
+      hash.update(t);
+
+      return hash.digest('base64');
+    });
+
+    return btoa(JSON.stringify(result));
+  }
+
+  private async getVQD(userAgent: string): Promise<VQDResponse> {
+    const response = await fetch("https://duckduckgo.com/duckchat/v1/status", {
+      headers: {
+        accept: "*/*",
+        "accept-language": "en-US,en;q=0.9,fa;q=0.8",
+        "cache-control": "no-store",
+        pragma: "no-cache",
+        priority: "u=1, i",
+        "sec-fetch-dest": "empty",
+        "sec-fetch-mode": "cors",
+        "sec-fetch-site": "same-origin",
+        "x-vqd-accept": "1",
+        "User-Agent": userAgent,
+      },
+      referrer: "https://duckduckgo.com/",
+      referrerPolicy: "origin",
+      method: "GET",
+      mode: "cors",
+      credentials: "include",
+    });
+
+    if (!response.ok) {
+      throw new Error(
+        `Failed to get VQD: ${response.status} ${response.statusText}`
+      );
+    }
+
+    const hashHeader = response.headers.get("x-Vqd-hash-1");
+
+    if (!hashHeader) {
+      throw new Error(
+        `Missing VQD headers: hash=${!!hashHeader}`
+      );
+    }
+
+    const encodedHash = await this.getEncodedVqdHash(hashHeader);
+
+    return { hash: encodedHash };
+  }
+
+  private async hashClientHashes(clientHashes: string[]): Promise<string[]> {
+    return Promise.all(
+      clientHashes.map(async (hash) => {
+        const encoder = new TextEncoder();
+        const data = encoder.encode(hash);
+        const hashBuffer = await crypto.subtle.digest("SHA-256", data);
+        const hashArray = new Uint8Array(hashBuffer);
+        return btoa(
+          hashArray.reduce((str, byte) => str + String.fromCharCode(byte), "")
+        );
+      })
+    );
+  }
+
+  async chat(request: DuckAIRequest): Promise<string> {
+    // Wait if rate limiting is needed
+    await this.waitIfNeeded();
+
+    const userAgent = new UserAgent().toString();
+    const vqd = await this.getVQD(userAgent);
+
+    // Update rate limit tracking BEFORE making the request
+    const now = Date.now();
+    this.rateLimitInfo.requestTimestamps.push(now);
+    this.rateLimitInfo.lastRequestTime = now;
+    this.saveRateLimitToStore();
+
+    // Show compact rate limit status in server console
+    this.rateLimitMonitor.printCompactStatus();
+
+    const response = await fetch("https://duckduckgo.com/duckchat/v1/chat", {
+      headers: {
+        accept: "text/event-stream",
+        "accept-language": "en-US,en;q=0.9,fa;q=0.8",
+        "cache-control": "no-cache",
+        "content-type": "application/json",
+        pragma: "no-cache",
+        priority: "u=1, i",
+        "sec-fetch-dest": "empty",
+        "sec-fetch-mode": "cors",
+        "sec-fetch-site": "same-origin",
+        "x-fe-version": "serp_20250401_100419_ET-19d438eb199b2bf7c300",
+        "User-Agent": userAgent,
+        "x-vqd-hash-1": vqd.hash,
+      },
+      referrer: "https://duckduckgo.com/",
+      referrerPolicy: "origin",
+      body: JSON.stringify(request),
+      method: "POST",
+      mode: "cors",
+      credentials: "include",
+    });
+
+    // Handle rate limiting
+    if (response.status === 429) {
+      const retryAfter = response.headers.get("retry-after");
+      const waitTime = retryAfter ? parseInt(retryAfter) * 1000 : 60000; // Default 1 minute
+      throw new Error(
+        `Rate limited. Retry after ${waitTime}ms. Status: ${response.status}`
+      );
+    }
+
+    if (!response.ok) {
+      throw new Error(
+        `DuckAI API error: ${response.status} ${response.statusText}`
+      );
+    }
+
+    const text = await response.text();
+
+    // Check for errors
+    try {
+      const parsed = JSON.parse(text);
+      if (parsed.action === "error") {
+        throw new Error(`Duck.ai error: ${JSON.stringify(parsed)}`);
+      }
+    } catch (e) {
+      // Not JSON, continue processing
+    }
+
+    // Extract the LLM response from the streamed response
+    let llmResponse = "";
+    const lines = text.split("\n");
+    for (const line of lines) {
+      if (line.startsWith("data: ")) {
+        try {
+          const json = JSON.parse(line.slice(6));
+          if (json.message) {
+            llmResponse += json.message;
+          }
+        } catch (e) {
+          // Skip invalid JSON lines
+        }
+      }
+    }
+
+    const finalResponse = llmResponse.trim();
+
+    // If response is empty, provide a fallback
+    if (!finalResponse) {
+      console.warn("Duck.ai returned empty response, using fallback");
+      return "I apologize, but I'm unable to provide a response at the moment. Please try again.";
+    }
+
+    return finalResponse;
+  }
+
+  async chatStream(request: DuckAIRequest): Promise<ReadableStream<string>> {
+    // Wait if rate limiting is needed
+    await this.waitIfNeeded();
+
+    const userAgent = new UserAgent().toString();
+    const vqd = await this.getVQD(userAgent);
+
+    // Update rate limit tracking BEFORE making the request
+    const now = Date.now();
+    this.rateLimitInfo.requestTimestamps.push(now);
+    this.rateLimitInfo.lastRequestTime = now;
+    this.saveRateLimitToStore();
+
+    // Show compact rate limit status in server console
+    this.rateLimitMonitor.printCompactStatus();
+
+    const response = await fetch("https://duckduckgo.com/duckchat/v1/chat", {
+      headers: {
+        accept: "text/event-stream",
+        "accept-language": "en-US,en;q=0.9,fa;q=0.8",
+        "cache-control": "no-cache",
+        "content-type": "application/json",
+        pragma: "no-cache",
+        priority: "u=1, i",
+        "sec-fetch-dest": "empty",
+        "sec-fetch-mode": "cors",
+        "sec-fetch-site": "same-origin",
+        "x-fe-version": "serp_20250401_100419_ET-19d438eb199b2bf7c300",
+        "User-Agent": userAgent,
+        "x-vqd-hash-1": vqd.hash,
+      },
+      referrer: "https://duckduckgo.com/",
+      referrerPolicy: "origin",
+      body: JSON.stringify(request),
+      method: "POST",
+      mode: "cors",
+      credentials: "include",
+    });
+
+    // Handle rate limiting
+    if (response.status === 429) {
+      const retryAfter = response.headers.get("retry-after");
+      const waitTime = retryAfter ? parseInt(retryAfter) * 1000 : 60000; // Default 1 minute
+      throw new Error(
+        `Rate limited. Retry after ${waitTime}ms. Status: ${response.status}`
+      );
+    }
+
+    if (!response.ok) {
+      throw new Error(
+        `DuckAI API error: ${response.status} ${response.statusText}`
+      );
+    }
+
+    if (!response.body) {
+      throw new Error("No response body");
+    }
+
+    return new ReadableStream({
+      start(controller) {
+        const reader = response.body!.getReader();
+        const decoder = new TextDecoder();
+
+        function pump(): Promise<void> {
+          return reader.read().then(({ done, value }) => {
+            if (done) {
+              controller.close();
+              return;
+            }
+
+            const chunk = decoder.decode(value, { stream: true });
+            const lines = chunk.split("\n");
+
+            for (const line of lines) {
+              if (line.startsWith("data: ")) {
+                try {
+                  const json = JSON.parse(line.slice(6));
+                  if (json.message) {
+                    controller.enqueue(json.message);
+                  }
+                } catch (e) {
+                  // Skip invalid JSON
+                }
+              }
+            }
+
+            return pump();
+          });
+        }
+
+        return pump();
+      },
+    });
+  }
+
+  getAvailableModels(): string[] {
+    return [
+      "gpt-4o-mini",
+      "gpt-5-mini",
+      "claude-3-5-haiku-latest",
+      "meta-llama/Llama-4-Scout-17B-16E-Instruct",
+      "mistralai/Mistral-Small-24B-Instruct-2501",
+      "openai/gpt-oss-120b"
+    ];
+  }
+}

openai-service.ts

@@ -0,0 +1,637 @@
+import { DuckAI } from "./duckai";
+import { ToolService } from "./tool-service";
+import type {
+  ChatCompletionRequest,
+  ChatCompletionResponse,
+  ChatCompletionStreamResponse,
+  ChatCompletionMessage,
+  ModelsResponse,
+  Model,
+  DuckAIRequest,
+  ToolDefinition,
+  ToolCall,
+} from "./types";
+
+export class OpenAIService {
+  private duckAI: DuckAI;
+  private toolService: ToolService;
+  private availableFunctions: Record<string, Function>;
+
+  constructor() {
+    this.duckAI = new DuckAI();
+    this.toolService = new ToolService();
+    this.availableFunctions = this.initializeBuiltInFunctions();
+  }
+
+  private initializeBuiltInFunctions(): Record<string, Function> {
+    return {
+      // Example built-in functions - users can extend this
+      get_current_time: () => new Date().toISOString(),
+      calculate: (args: { expression: string }) => {
+        try {
+          // Simple calculator - in production, use a proper math parser
+          const result = Function(
+            `"use strict"; return (${args.expression})`
+          )();
+          return { result };
+        } catch (error) {
+          return { error: "Invalid expression" };
+        }
+      },
+      get_weather: (args: { location: string }) => {
+        // Mock weather function
+        return {
+          location: args.location,
+          temperature: Math.floor(Math.random() * 30) + 10,
+          condition: ["sunny", "cloudy", "rainy"][
+            Math.floor(Math.random() * 3)
+          ],
+          note: "This is a mock weather function for demonstration",
+        };
+      },
+    };
+  }
+
+  registerFunction(name: string, func: Function): void {
+    this.availableFunctions[name] = func;
+  }
+
+  private generateId(): string {
+    return `chatcmpl-${Math.random().toString(36).substring(2, 15)}`;
+  }
+
+  private getCurrentTimestamp(): number {
+    return Math.floor(Date.now() / 1000);
+  }
+
+  private estimateTokens(text: string): number {
+    // Rough estimation: ~4 characters per token
+    return Math.ceil(text.length / 4);
+  }
+
+  private transformToDuckAIRequest(
+    request: ChatCompletionRequest
+  ): DuckAIRequest {
+    // Use the model from request, fallback to default
+    const model = request.model || "mistralai/Mistral-Small-24B-Instruct-2501";
+
+    return {
+      model,
+      messages: request.messages,
+    };
+  }
+
+  async createChatCompletion(
+    request: ChatCompletionRequest
+  ): Promise<ChatCompletionResponse> {
+    // Check if this request involves function calling
+    if (
+      this.toolService.shouldUseFunctionCalling(
+        request.tools,
+        request.tool_choice
+      )
+    ) {
+      return this.createChatCompletionWithTools(request);
+    }
+
+    const duckAIRequest = this.transformToDuckAIRequest(request);
+    const response = await this.duckAI.chat(duckAIRequest);
+
+    const id = this.generateId();
+    const created = this.getCurrentTimestamp();
+
+    // Calculate token usage
+    const promptText = request.messages.map((m) => m.content || "").join(" ");
+    const promptTokens = this.estimateTokens(promptText);
+    const completionTokens = this.estimateTokens(response);
+
+    return {
+      id,
+      object: "chat.completion",
+      created,
+      model: request.model,
+      choices: [
+        {
+          index: 0,
+          message: {
+            role: "assistant",
+            content: response,
+          },
+          finish_reason: "stop",
+        },
+      ],
+      usage: {
+        prompt_tokens: promptTokens,
+        completion_tokens: completionTokens,
+        total_tokens: promptTokens + completionTokens,
+      },
+    };
+  }
+
+  private async createChatCompletionWithTools(
+    request: ChatCompletionRequest
+  ): Promise<ChatCompletionResponse> {
+    const id = this.generateId();
+    const created = this.getCurrentTimestamp();
+
+    // Validate tools
+    if (request.tools) {
+      const validation = this.toolService.validateTools(request.tools);
+      if (!validation.valid) {
+        throw new Error(`Invalid tools: ${validation.errors.join(", ")}`);
+      }
+    }
+
+    // Create a modified request with tool instructions
+    const modifiedMessages = [...request.messages];
+
+    // Add tool instructions as user message (DuckAI doesn't support system messages)
+    if (request.tools && request.tools.length > 0) {
+      const toolPrompt = this.toolService.generateToolSystemPrompt(
+        request.tools,
+        request.tool_choice
+      );
+      modifiedMessages.unshift({
+        role: "user",
+        content: `[SYSTEM INSTRUCTIONS] ${toolPrompt}
+
+Please follow these instructions when responding to the following user message.`,
+      });
+    }
+
+    const duckAIRequest = this.transformToDuckAIRequest({
+      ...request,
+      messages: modifiedMessages,
+    });
+
+    const response = await this.duckAI.chat(duckAIRequest);
+
+    // Check if the response contains function calls
+    if (this.toolService.detectFunctionCalls(response)) {
+      const toolCalls = this.toolService.extractFunctionCalls(response);
+
+      if (toolCalls.length > 0) {
+        // Calculate token usage
+        const promptText = modifiedMessages
+          .map((m) => m.content || "")
+          .join(" ");
+        const promptTokens = this.estimateTokens(promptText);
+        const completionTokens = this.estimateTokens(response);
+
+        return {
+          id,
+          object: "chat.completion",
+          created,
+          model: request.model,
+          choices: [
+            {
+              index: 0,
+              message: {
+                role: "assistant",
+                content: null,
+                tool_calls: toolCalls,
+              },
+              finish_reason: "tool_calls",
+            },
+          ],
+          usage: {
+            prompt_tokens: promptTokens,
+            completion_tokens: completionTokens,
+            total_tokens: promptTokens + completionTokens,
+          },
+        };
+      }
+    }
+
+    // No function calls detected
+    // If tool_choice is "required" or specific function, we need to force a function call
+    if (
+      (request.tool_choice === "required" ||
+        (typeof request.tool_choice === "object" &&
+          request.tool_choice.type === "function")) &&
+      request.tools &&
+      request.tools.length > 0
+    ) {
+      // Get user message for argument extraction
+      const userMessage = request.messages[request.messages.length - 1];
+      const userContent = userMessage.content || "";
+
+      // Determine which function to call
+      let functionToCall: string;
+
+      // If specific function is requested, use that
+      if (
+        typeof request.tool_choice === "object" &&
+        request.tool_choice.type === "function"
+      ) {
+        functionToCall = request.tool_choice.function.name;
+      } else {
+        // Try to infer which function to call based on the user's request
+        // Simple heuristics to choose appropriate function
+        functionToCall = request.tools[0].function.name; // Default to first function
+
+        if (userContent.toLowerCase().includes("time")) {
+          const timeFunction = request.tools.find(
+            (t) => t.function.name === "get_current_time"
+          );
+          if (timeFunction) functionToCall = timeFunction.function.name;
+        } else if (
+          userContent.toLowerCase().includes("calculate") ||
+          /\d+\s*[+\-*/]\s*\d+/.test(userContent)
+        ) {
+          const calcFunction = request.tools.find(
+            (t) => t.function.name === "calculate"
+          );
+          if (calcFunction) functionToCall = calcFunction.function.name;
+        } else if (userContent.toLowerCase().includes("weather")) {
+          const weatherFunction = request.tools.find(
+            (t) => t.function.name === "get_weather"
+          );
+          if (weatherFunction) functionToCall = weatherFunction.function.name;
+        }
+      }
+
+      // Generate appropriate arguments based on function
+      let args = "{}";
+      if (functionToCall === "calculate") {
+        const mathMatch = userContent.match(/(\d+\s*[+\-*/]\s*\d+)/);
+        if (mathMatch) {
+          args = JSON.stringify({ expression: mathMatch[1] });
+        }
+      } else if (functionToCall === "get_weather") {
+        // Try to extract location from user message
+        const locationMatch = userContent.match(
+          /(?:in|for|at)\s+([A-Za-z\s,]+)/i
+        );
+        if (locationMatch) {
+          args = JSON.stringify({ location: locationMatch[1].trim() });
+        }
+      }
+
+      const forcedToolCall: ToolCall = {
+        id: `call_${Date.now()}`,
+        type: "function",
+        function: {
+          name: functionToCall,
+          arguments: args,
+        },
+      };
+
+      const promptText = modifiedMessages.map((m) => m.content || "").join(" ");
+      const promptTokens = this.estimateTokens(promptText);
+      const completionTokens = this.estimateTokens(
+        JSON.stringify(forcedToolCall)
+      );
+
+      return {
+        id,
+        object: "chat.completion",
+        created,
+        model: request.model,
+        choices: [
+          {
+            index: 0,
+            message: {
+              role: "assistant",
+              content: null,
+              tool_calls: [forcedToolCall],
+            },
+            finish_reason: "tool_calls",
+          },
+        ],
+        usage: {
+          prompt_tokens: promptTokens,
+          completion_tokens: completionTokens,
+          total_tokens: promptTokens + completionTokens,
+        },
+      };
+    }
+
+    // No function calls detected, return normal response
+    const promptText = modifiedMessages.map((m) => m.content || "").join(" ");
+    const promptTokens = this.estimateTokens(promptText);
+    const completionTokens = this.estimateTokens(response);
+
+    return {
+      id,
+      object: "chat.completion",
+      created,
+      model: request.model,
+      choices: [
+        {
+          index: 0,
+          message: {
+            role: "assistant",
+            content: response,
+          },
+          finish_reason: "stop",
+        },
+      ],
+      usage: {
+        prompt_tokens: promptTokens,
+        completion_tokens: completionTokens,
+        total_tokens: promptTokens + completionTokens,
+      },
+    };
+  }
+
+  async createChatCompletionStream(
+    request: ChatCompletionRequest
+  ): Promise<ReadableStream<Uint8Array>> {
+    // Check if this request involves function calling
+    if (
+      this.toolService.shouldUseFunctionCalling(
+        request.tools,
+        request.tool_choice
+      )
+    ) {
+      return this.createChatCompletionStreamWithTools(request);
+    }
+
+    const duckAIRequest = this.transformToDuckAIRequest(request);
+    const duckStream = await this.duckAI.chatStream(duckAIRequest);
+
+    const id = this.generateId();
+    const created = this.getCurrentTimestamp();
+
+    return new ReadableStream({
+      start(controller) {
+        const reader = duckStream.getReader();
+        let isFirst = true;
+
+        function pump(): Promise<void> {
+          return reader.read().then(({ done, value }) => {
+            if (done) {
+              // Send final chunk
+              const finalChunk: ChatCompletionStreamResponse = {
+                id,
+                object: "chat.completion.chunk",
+                created,
+                model: request.model,
+                choices: [
+                  {
+                    index: 0,
+                    delta: {},
+                    finish_reason: "stop",
+                  },
+                ],
+              };
+
+              const finalData = `data: ${JSON.stringify(finalChunk)}\n\n`;
+              const finalDone = `data: [DONE]\n\n`;
+
+              controller.enqueue(new TextEncoder().encode(finalData));
+              controller.enqueue(new TextEncoder().encode(finalDone));
+              controller.close();
+              return;
+            }
+
+            const chunk: ChatCompletionStreamResponse = {
+              id,
+              object: "chat.completion.chunk",
+              created,
+              model: request.model,
+              choices: [
+                {
+                  index: 0,
+                  delta: isFirst
+                    ? { role: "assistant", content: value }
+                    : { content: value },
+                  finish_reason: null,
+                },
+              ],
+            };
+
+            isFirst = false;
+            const data = `data: ${JSON.stringify(chunk)}\n\n`;
+            controller.enqueue(new TextEncoder().encode(data));
+
+            return pump();
+          });
+        }
+
+        return pump();
+      },
+    });
+  }
+
+  private async createChatCompletionStreamWithTools(
+    request: ChatCompletionRequest
+  ): Promise<ReadableStream<Uint8Array>> {
+    // For tools, we need to collect the full response first to parse function calls
+    // This is a limitation of the "trick" approach - streaming with tools is complex
+    const completion = await this.createChatCompletionWithTools(request);
+
+    const id = completion.id;
+    const created = completion.created;
+
+    return new ReadableStream({
+      start(controller) {
+        const choice = completion.choices[0];
+
+        if (choice.message.tool_calls) {
+          // Stream tool calls
+          const toolCallsChunk: ChatCompletionStreamResponse = {
+            id,
+            object: "chat.completion.chunk",
+            created,
+            model: request.model,
+            choices: [
+              {
+                index: 0,
+                delta: {
+                  role: "assistant",
+                  tool_calls: choice.message.tool_calls,
+                },
+                finish_reason: null,
+              },
+            ],
+          };
+
+          const toolCallsData = `data: ${JSON.stringify(toolCallsChunk)}\n\n`;
+          controller.enqueue(new TextEncoder().encode(toolCallsData));
+
+          // Send final chunk
+          const finalChunk: ChatCompletionStreamResponse = {
+            id,
+            object: "chat.completion.chunk",
+            created,
+            model: request.model,
+            choices: [
+              {
+                index: 0,
+                delta: {},
+                finish_reason: "tool_calls",
+              },
+            ],
+          };
+
+          const finalData = `data: ${JSON.stringify(finalChunk)}\n\n`;
+          const finalDone = `data: [DONE]\n\n`;
+
+          controller.enqueue(new TextEncoder().encode(finalData));
+          controller.enqueue(new TextEncoder().encode(finalDone));
+        } else {
+          // Stream regular content
+          const content = choice.message.content || "";
+
+          // Send role first
+          const roleChunk: ChatCompletionStreamResponse = {
+            id,
+            object: "chat.completion.chunk",
+            created,
+            model: request.model,
+            choices: [
+              {
+                index: 0,
+                delta: { role: "assistant" },
+                finish_reason: null,
+              },
+            ],
+          };
+
+          const roleData = `data: ${JSON.stringify(roleChunk)}\n\n`;
+          controller.enqueue(new TextEncoder().encode(roleData));
+
+          // Stream content in chunks
+          const chunkSize = 10;
+          for (let i = 0; i < content.length; i += chunkSize) {
+            const contentChunk = content.slice(i, i + chunkSize);
+
+            const chunk: ChatCompletionStreamResponse = {
+              id,
+              object: "chat.completion.chunk",
+              created,
+              model: request.model,
+              choices: [
+                {
+                  index: 0,
+                  delta: { content: contentChunk },
+                  finish_reason: null,
+                },
+              ],
+            };
+
+            const data = `data: ${JSON.stringify(chunk)}\n\n`;
+            controller.enqueue(new TextEncoder().encode(data));
+          }
+
+          // Send final chunk
+          const finalChunk: ChatCompletionStreamResponse = {
+            id,
+            object: "chat.completion.chunk",
+            created,
+            model: request.model,
+            choices: [
+              {
+                index: 0,
+                delta: {},
+                finish_reason: "stop",
+              },
+            ],
+          };
+
+          const finalData = `data: ${JSON.stringify(finalChunk)}\n\n`;
+          const finalDone = `data: [DONE]\n\n`;
+
+          controller.enqueue(new TextEncoder().encode(finalData));
+          controller.enqueue(new TextEncoder().encode(finalDone));
+        }
+
+        controller.close();
+      },
+    });
+  }
+
+  getModels(): ModelsResponse {
+    const models = this.duckAI.getAvailableModels();
+    const created = this.getCurrentTimestamp();
+
+    const modelData: Model[] = models.map((modelId) => ({
+      id: modelId,
+      object: "model",
+      created,
+      owned_by: "duckai",
+    }));
+
+    return {
+      object: "list",
+      data: modelData,
+    };
+  }
+
+  validateRequest(request: any): ChatCompletionRequest {
+    if (!request.messages || !Array.isArray(request.messages)) {
+      throw new Error("messages field is required and must be an array");
+    }
+
+    if (request.messages.length === 0) {
+      throw new Error("messages array cannot be empty");
+    }
+
+    for (const message of request.messages) {
+      if (
+        !message.role ||
+        !["system", "user", "assistant", "tool"].includes(message.role)
+      ) {
+        throw new Error(
+          "Each message must have a valid role (system, user, assistant, or tool)"
+        );
+      }
+
+      // Tool messages have different validation rules
+      if (message.role === "tool") {
+        if (!message.tool_call_id) {
+          throw new Error("Tool messages must have a tool_call_id");
+        }
+        if (typeof message.content !== "string") {
+          throw new Error("Tool messages must have content as a string");
+        }
+      } else {
+        // For non-tool messages, content can be null if there are tool_calls
+        if (
+          message.content === undefined ||
+          (message.content !== null && typeof message.content !== "string")
+        ) {
+          throw new Error("Each message must have content as a string or null");
+        }
+      }
+    }
+
+    // Validate tools if provided
+    if (request.tools) {
+      const validation = this.toolService.validateTools(request.tools);
+      if (!validation.valid) {
+        throw new Error(`Invalid tools: ${validation.errors.join(", ")}`);
+      }
+    }
+
+    return {
+      model: request.model || "mistralai/Mistral-Small-24B-Instruct-2501",
+      messages: request.messages,
+      temperature: request.temperature,
+      max_tokens: request.max_tokens,
+      stream: request.stream || false,
+      top_p: request.top_p,
+      frequency_penalty: request.frequency_penalty,
+      presence_penalty: request.presence_penalty,
+      stop: request.stop,
+      tools: request.tools,
+      tool_choice: request.tool_choice,
+    };
+  }
+
+  async executeToolCall(toolCall: ToolCall): Promise<string> {
+    return this.toolService.executeFunctionCall(
+      toolCall,
+      this.availableFunctions
+    );
+  }
+
+  /**
+   * Get current rate limit status from DuckAI
+   */
+  getRateLimitStatus() {
+    return this.duckAI.getRateLimitStatus();
+  }
+}

rate-limit-store.ts

@@ -0,0 +1,110 @@
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs";
+import { join } from "path";
+import { tmpdir } from "os";
+
+interface RateLimitData {
+  // Support both old and new formats for backward compatibility
+  requestCount?: number; // Old format
+  windowStart?: number; // Old format
+  requestTimestamps?: number[]; // New sliding window format
+  lastRequestTime: number;
+  isLimited: boolean;
+  retryAfter?: number;
+  processId: string;
+  lastUpdated: number;
+}
+
+export class RateLimitStore {
+  private readonly storeDir: string;
+  private readonly storeFile: string;
+  private readonly processId: string;
+
+  constructor() {
+    this.storeDir = join(tmpdir(), "duckai");
+    this.storeFile = join(this.storeDir, "rate-limit.json");
+    this.processId = `${process.pid}-${Date.now()}`;
+
+    // Ensure directory exists
+    if (!existsSync(this.storeDir)) {
+      mkdirSync(this.storeDir, { recursive: true });
+    }
+  }
+
+  /**
+   * Read rate limit data from shared store
+   */
+  read(): RateLimitData | null {
+    try {
+      if (!existsSync(this.storeFile)) {
+        return null;
+      }
+
+      const data = readFileSync(this.storeFile, "utf8");
+
+      // Handle empty file
+      if (!data.trim()) {
+        return null;
+      }
+
+      const parsed: RateLimitData = JSON.parse(data);
+
+      // Check if data is stale (older than 5 minutes)
+      const now = Date.now();
+      if (now - parsed.lastUpdated > 5 * 60 * 1000) {
+        return null;
+      }
+
+      return parsed;
+    } catch (error) {
+      // Don't log warnings for expected cases like empty files
+      return null;
+    }
+  }
+
+  /**
+   * Write rate limit data to shared store
+   */
+  write(data: Omit<RateLimitData, "processId" | "lastUpdated">): void {
+    try {
+      const storeData: RateLimitData = {
+        ...data,
+        processId: this.processId,
+        lastUpdated: Date.now(),
+      };
+
+      writeFileSync(this.storeFile, JSON.stringify(storeData, null, 2));
+    } catch (error) {
+      console.warn("Failed to write rate limit store:", error);
+    }
+  }
+
+  /**
+   * Update rate limit data atomically
+   */
+  update(updater: (current: RateLimitData | null) => RateLimitData): void {
+    const current = this.read();
+    const updated = updater(current);
+    this.write(updated);
+  }
+
+  /**
+   * Clear the store
+   */
+  clear(): void {
+    try {
+      if (existsSync(this.storeFile)) {
+        const fs = require("fs");
+        fs.unlinkSync(this.storeFile);
+      }
+    } catch (error) {
+      console.warn("Failed to clear rate limit store:", error);
+    }
+  }
+
+  /**
+   * Get store file path for debugging
+   */
+  getStorePath(): string {
+    return this.storeFile;
+  }
+}

server.ts

@@ -0,0 +1,123 @@
+import { OpenAIService } from "./openai-service";
+
+const openAIService = new OpenAIService();
+
+const server = Bun.serve({
+  port: process.env.PORT || 3000,
+  async fetch(req) {
+    const url = new URL(req.url);
+
+    // CORS headers
+    const corsHeaders = {
+      "Access-Control-Allow-Origin": "*",
+      "Access-Control-Allow-Methods": "GET, POST, OPTIONS",
+      "Access-Control-Allow-Headers": "Content-Type, Authorization",
+    };
+
+    // Handle preflight requests
+    if (req.method === "OPTIONS") {
+      return new Response(null, { headers: corsHeaders });
+    }
+
+    try {
+      // Health check endpoint
+      if (url.pathname === "/health" && req.method === "GET") {
+        return new Response(JSON.stringify({ status: "ok" }), {
+          headers: { "Content-Type": "application/json", ...corsHeaders },
+        });
+      }
+
+      // Models endpoint
+      if (url.pathname === "/v1/models" && req.method === "GET") {
+        const models = openAIService.getModels();
+        return new Response(JSON.stringify(models), {
+          headers: { "Content-Type": "application/json", ...corsHeaders },
+        });
+      }
+
+      // Chat completions endpoint
+      if (url.pathname === "/v1/chat/completions" && req.method === "POST") {
+        const body = await req.json();
+        const validatedRequest = openAIService.validateRequest(body);
+
+        // Handle streaming
+        if (validatedRequest.stream) {
+          const stream =
+            await openAIService.createChatCompletionStream(validatedRequest);
+          return new Response(stream, {
+            headers: {
+              "Content-Type": "text/event-stream",
+              "Cache-Control": "no-cache",
+              Connection: "keep-alive",
+              ...corsHeaders,
+            },
+          });
+        }
+
+        // Handle non-streaming
+        const completion =
+          await openAIService.createChatCompletion(validatedRequest);
+        return new Response(JSON.stringify(completion), {
+          headers: { "Content-Type": "application/json", ...corsHeaders },
+        });
+      }
+
+      // 404 for unknown endpoints
+      return new Response(
+        JSON.stringify({
+          error: {
+            message: "Not found",
+            type: "invalid_request_error",
+          },
+        }),
+        {
+          status: 404,
+          headers: { "Content-Type": "application/json", ...corsHeaders },
+        }
+      );
+    } catch (error) {
+      console.error("Server error:", error);
+
+      const errorMessage =
+        error instanceof Error ? error.message : "Internal server error";
+      const statusCode =
+        errorMessage.includes("required") || errorMessage.includes("must")
+          ? 400
+          : 500;
+
+      return new Response(
+        JSON.stringify({
+          error: {
+            message: errorMessage,
+            type:
+              statusCode === 400
+                ? "invalid_request_error"
+                : "internal_server_error",
+          },
+        }),
+        {
+          status: statusCode,
+          headers: { "Content-Type": "application/json", ...corsHeaders },
+        }
+      );
+    }
+  },
+});
+
+console.log(
+  `🚀 OpenAI-compatible server running on http://localhost:${server.port}`
+);
+console.log(`📚 Available endpoints:`);
+console.log(`  GET  /health - Health check`);
+console.log(`  GET  /v1/models - List available models`);
+console.log(
+  `  POST /v1/chat/completions - Chat completions (streaming & non-streaming)`
+);
+console.log(`\n🔧 Example usage:`);
+console.log(
+  `curl -X POST http://localhost:${server.port}/v1/chat/completions \\`
+);
+console.log(`  -H "Content-Type: application/json" \\`);
+console.log(
+  `  -d '{"model":"gpt-4o-mini","messages":[{"role":"user","content":"Hello!"}]}'`
+);

shared-rate-limit-monitor.ts

@@ -0,0 +1,361 @@
+import { RateLimitStore } from "./rate-limit-store";
+
+/**
+ * Shared Rate Limit Monitor
+ *
+ * This monitor reads rate limit data from a shared store,
+ * allowing it to display real-time rate limit information
+ * across all DuckAI processes.
+ */
+export class SharedRateLimitMonitor {
+  private rateLimitStore: RateLimitStore;
+  private monitoringInterval?: NodeJS.Timeout;
+
+  // Rate limit constants (should match DuckAI class)
+  private readonly MAX_REQUESTS_PER_MINUTE = 20;
+  private readonly WINDOW_SIZE_MS = 60 * 1000; // 1 minute
+  private readonly MIN_REQUEST_INTERVAL_MS = 1000; // 1 second
+
+  constructor() {
+    this.rateLimitStore = new RateLimitStore();
+  }
+
+  /**
+   * Clean old timestamps outside the sliding window
+   */
+  private cleanOldTimestamps(timestamps: number[]): number[] {
+    const now = Date.now();
+    const cutoff = now - this.WINDOW_SIZE_MS;
+    return timestamps.filter((timestamp) => timestamp > cutoff);
+  }
+
+  /**
+   * Get current rate limit status from shared store
+   */
+  getCurrentStatus() {
+    const stored = this.rateLimitStore.read();
+
+    if (!stored) {
+      // No data available, return default state
+      return {
+        requestsInCurrentWindow: 0,
+        maxRequestsPerMinute: this.MAX_REQUESTS_PER_MINUTE,
+        timeUntilWindowReset: this.WINDOW_SIZE_MS,
+        isCurrentlyLimited: false,
+        recommendedWaitTime: 0,
+        utilizationPercentage: 0,
+        timeUntilWindowResetMinutes: 1,
+        recommendedWaitTimeSeconds: 0,
+        dataSource: "default" as const,
+        lastUpdated: null,
+      };
+    }
+
+    const now = Date.now();
+    let requestsInWindow: number;
+    let timeUntilReset: number;
+
+    // Handle both old and new formats
+    if (stored.requestTimestamps) {
+      // New sliding window format
+      const cleanTimestamps = this.cleanOldTimestamps(stored.requestTimestamps);
+      requestsInWindow = cleanTimestamps.length;
+
+      // For sliding window, calculate when the oldest request will expire
+      const oldestTimestamp = cleanTimestamps[0];
+      timeUntilReset = oldestTimestamp
+        ? Math.max(0, oldestTimestamp + this.WINDOW_SIZE_MS - now)
+        : 0;
+    } else {
+      // Old fixed window format (backward compatibility)
+      const windowElapsed = now - (stored.windowStart || 0);
+      requestsInWindow = stored.requestCount || 0;
+      timeUntilReset = this.WINDOW_SIZE_MS - windowElapsed;
+
+      if (windowElapsed >= this.WINDOW_SIZE_MS) {
+        requestsInWindow = 0;
+        timeUntilReset = this.WINDOW_SIZE_MS;
+      }
+    }
+
+    // Calculate recommended wait time
+    const timeSinceLastRequest = now - stored.lastRequestTime;
+    const recommendedWait = Math.max(
+      0,
+      this.MIN_REQUEST_INTERVAL_MS - timeSinceLastRequest
+    );
+
+    const utilizationPercentage =
+      (requestsInWindow / this.MAX_REQUESTS_PER_MINUTE) * 100;
+
+    return {
+      requestsInCurrentWindow: requestsInWindow,
+      maxRequestsPerMinute: this.MAX_REQUESTS_PER_MINUTE,
+      timeUntilWindowReset: Math.max(0, timeUntilReset),
+      isCurrentlyLimited: stored.isLimited,
+      recommendedWaitTime: recommendedWait,
+      utilizationPercentage,
+      timeUntilWindowResetMinutes: Math.ceil(
+        Math.max(0, timeUntilReset) / 60000
+      ),
+      recommendedWaitTimeSeconds: Math.ceil(recommendedWait / 1000),
+      dataSource: "shared" as const,
+      lastUpdated: new Date(stored.lastUpdated).toISOString(),
+      processId: stored.processId,
+      windowType: stored.requestTimestamps ? "sliding" : "fixed",
+    };
+  }
+
+  /**
+   * Print current rate limit status to console
+   */
+  printStatus(clearConsole: boolean = false) {
+    if (clearConsole) {
+      // Clear console for cleaner monitoring display
+      console.clear();
+    }
+
+    const status = this.getCurrentStatus();
+
+    const windowTypeIcon =
+      (status as any).windowType === "sliding" ? "🔄" : "⏰";
+    const windowTypeText =
+      (status as any).windowType === "sliding"
+        ? "Sliding Window"
+        : "Fixed Window";
+
+    console.log(`\n🔍 DuckAI Rate Limit Status (${windowTypeText}):`);
+    console.log("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
+    console.log(
+      `📊 Requests in current window: ${status.requestsInCurrentWindow}/${status.maxRequestsPerMinute}`
+    );
+    console.log(`📈 Utilization: ${status.utilizationPercentage.toFixed(1)}%`);
+
+    if ((status as any).windowType === "sliding") {
+      console.log(
+        `${windowTypeIcon} Next request expires in: ${status.timeUntilWindowResetMinutes} minutes`
+      );
+    } else {
+      console.log(
+        `${windowTypeIcon} Window resets in: ${status.timeUntilWindowResetMinutes} minutes`
+      );
+    }
+
+    console.log(
+      `🚦 Currently limited: ${status.isCurrentlyLimited ? "❌ Yes" : "✅ No"}`
+    );
+
+    if (status.recommendedWaitTimeSeconds > 0) {
+      console.log(
+        `⏳ Recommended wait: ${status.recommendedWaitTimeSeconds} seconds`
+      );
+    }
+
+    // Data source info
+    if (status.dataSource === "shared" && status.lastUpdated) {
+      const updateTime = new Date(status.lastUpdated).toLocaleTimeString();
+      console.log(`📡 Data from: Process ${status.processId} at ${updateTime}`);
+    } else {
+      console.log(`📡 Data source: ${status.dataSource} (no active processes)`);
+    }
+
+    // Visual progress bar
+    const barLength = 20;
+    const filledLength = Math.round(
+      (status.utilizationPercentage / 100) * barLength
+    );
+    const bar = "█".repeat(filledLength) + "░".repeat(barLength - filledLength);
+    console.log(
+      `📊 Usage: [${bar}] ${status.utilizationPercentage.toFixed(1)}%`
+    );
+    console.log("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n");
+  }
+
+  /**
+   * Print compact rate limit status for server console
+   */
+  printCompactStatus() {
+    const status = this.getCurrentStatus();
+    const windowType = (status as any).windowType === "sliding" ? "🔄" : "⏰";
+    const limitIcon = status.isCurrentlyLimited ? "❌" : "✅";
+
+    console.log(
+      `${windowType} Rate Limit: ${status.requestsInCurrentWindow}/${status.maxRequestsPerMinute} (${status.utilizationPercentage.toFixed(1)}%) ${limitIcon}`
+    );
+  }
+
+  /**
+   * Start continuous monitoring (prints status every interval)
+   */
+  startMonitoring(intervalSeconds: number = 30) {
+    console.log(
+      `🔄 Starting shared rate limit monitoring (every ${intervalSeconds}s)...`
+    );
+    console.log(`📁 Store location: ${this.rateLimitStore.getStorePath()}`);
+    this.printStatus();
+
+    this.monitoringInterval = setInterval(() => {
+      this.printStatus(true); // Clear console for each update
+    }, intervalSeconds * 1000);
+  }
+
+  /**
+   * Stop continuous monitoring
+   */
+  stopMonitoring() {
+    if (this.monitoringInterval) {
+      clearInterval(this.monitoringInterval);
+      this.monitoringInterval = undefined;
+      console.log("⏹️  Shared rate limit monitoring stopped.");
+    }
+  }
+
+  /**
+   * Get recommendations for optimal usage
+   */
+  getRecommendations() {
+    const status = this.getCurrentStatus();
+    const recommendations: string[] = [];
+
+    if (status.dataSource === "default") {
+      recommendations.push(
+        "ℹ️  No active DuckAI processes detected. Start making API calls to see real data."
+      );
+    }
+
+    if (status.utilizationPercentage > 80) {
+      recommendations.push(
+        "⚠️  High utilization detected. Consider implementing request queuing."
+      );
+    }
+
+    if (status.recommendedWaitTimeSeconds > 0) {
+      recommendations.push(
+        `⏳ Wait ${status.recommendedWaitTimeSeconds}s before next request.`
+      );
+    }
+
+    if (status.isCurrentlyLimited) {
+      recommendations.push(
+        "🚫 Currently rate limited. Wait for window reset or implement exponential backoff."
+      );
+    }
+
+    if (status.utilizationPercentage < 50 && status.dataSource === "shared") {
+      recommendations.push(
+        "✅ Good utilization level. You can safely increase request frequency."
+      );
+    }
+
+    recommendations.push(
+      "💡 Consider implementing request batching for better efficiency."
+    );
+    recommendations.push("🔄 Use exponential backoff for retry logic.");
+    recommendations.push("📊 Monitor rate limits continuously in production.");
+
+    return recommendations;
+  }
+
+  /**
+   * Print recommendations
+   */
+  printRecommendations() {
+    const recommendations = this.getRecommendations();
+
+    console.log("\n💡 Rate Limit Recommendations:");
+    console.log("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
+    recommendations.forEach((rec) => console.log(rec));
+    console.log("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n");
+  }
+
+  /**
+   * Clear the shared rate limit store
+   */
+  clearStore() {
+    this.rateLimitStore.clear();
+    console.log("🗑️  Shared rate limit store cleared.");
+  }
+
+  /**
+   * Get store information
+   */
+  getStoreInfo() {
+    const stored = this.rateLimitStore.read();
+    return {
+      storePath: this.rateLimitStore.getStorePath(),
+      hasData: !!stored,
+      data: stored,
+    };
+  }
+}
+
+// CLI usage for shared monitoring
+if (require.main === module) {
+  const monitor = new SharedRateLimitMonitor();
+
+  // Parse command line arguments
+  const args = process.argv.slice(2);
+  const command = args[0];
+
+  switch (command) {
+    case "status":
+      monitor.printStatus();
+      monitor.printRecommendations();
+      break;
+
+    case "monitor":
+      const interval = parseInt(args[1]) || 30;
+      monitor.startMonitoring(interval);
+
+      // Stop monitoring on Ctrl+C
+      process.on("SIGINT", () => {
+        monitor.stopMonitoring();
+        process.exit(0);
+      });
+      break;
+
+    case "clear":
+      monitor.clearStore();
+      break;
+
+    case "info":
+      const info = monitor.getStoreInfo();
+      console.log("📁 Store Information:");
+      console.log(`   Path: ${info.storePath}`);
+      console.log(`   Has Data: ${info.hasData}`);
+      if (info.data) {
+        console.log(
+          `   Last Updated: ${new Date(info.data.lastUpdated).toLocaleString()}`
+        );
+        console.log(`   Process ID: ${info.data.processId}`);
+        console.log(`   Requests: ${info.data.requestCount}`);
+      }
+      break;
+
+    default:
+      console.log("🔍 DuckAI Shared Rate Limit Monitor");
+      console.log("");
+      console.log("This monitor reads rate limit data from a shared store,");
+      console.log("showing real-time information across all DuckAI processes.");
+      console.log("");
+      console.log("Usage:");
+      console.log(
+        "  bun run src/shared-rate-limit-monitor.ts status                    # Show current status"
+      );
+      console.log(
+        "  bun run src/shared-rate-limit-monitor.ts monitor [interval]       # Start monitoring (default: 30s)"
+      );
+      console.log(
+        "  bun run src/shared-rate-limit-monitor.ts clear                     # Clear stored data"
+      );
+      console.log(
+        "  bun run src/shared-rate-limit-monitor.ts info                      # Show store info"
+      );
+      console.log("");
+      console.log("Examples:");
+      console.log("  bun run src/shared-rate-limit-monitor.ts status");
+      console.log("  bun run src/shared-rate-limit-monitor.ts monitor 10");
+      console.log("  bun run src/shared-rate-limit-monitor.ts clear");
+      break;
+  }
+}

shared-rate-limit-tester.ts

@@ -0,0 +1,232 @@
+import { DuckAI } from "./duckai";
+
+/**
+ * Shared Rate Limit Tester
+ *
+ * This utility tests rate limits using the DuckAI class which writes to the shared store,
+ * allowing cross-process monitoring to work correctly.
+ */
+export class SharedRateLimitTester {
+  private duckAI: DuckAI;
+
+  constructor() {
+    this.duckAI = new DuckAI();
+  }
+
+  /**
+   * Get current rate limit status
+   */
+  getCurrentStatus() {
+    const status = this.duckAI.getRateLimitStatus();
+    return {
+      ...status,
+      utilizationPercentage:
+        (status.requestsInCurrentWindow / status.maxRequestsPerMinute) * 100,
+      timeUntilWindowResetMinutes: Math.ceil(
+        status.timeUntilWindowReset / 60000
+      ),
+      recommendedWaitTimeSeconds: Math.ceil(status.recommendedWaitTime / 1000),
+    };
+  }
+
+  /**
+   * Print current rate limit status to console
+   */
+  printStatus() {
+    const status = this.getCurrentStatus();
+
+    console.log("\n🔍 DuckAI Rate Limit Status (Shared Tester):");
+    console.log("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
+    console.log(
+      `📊 Requests in current window: ${status.requestsInCurrentWindow}/${status.maxRequestsPerMinute}`
+    );
+    console.log(`📈 Utilization: ${status.utilizationPercentage.toFixed(1)}%`);
+    console.log(
+      `⏰ Window resets in: ${status.timeUntilWindowResetMinutes} minutes`
+    );
+    console.log(
+      `🚦 Currently limited: ${status.isCurrentlyLimited ? "❌ Yes" : "✅ No"}`
+    );
+
+    if (status.recommendedWaitTimeSeconds > 0) {
+      console.log(
+        `⏳ Recommended wait: ${status.recommendedWaitTimeSeconds} seconds`
+      );
+    }
+
+    // Visual progress bar
+    const barLength = 20;
+    const filledLength = Math.round(
+      (status.utilizationPercentage / 100) * barLength
+    );
+    const bar = "█".repeat(filledLength) + "░".repeat(barLength - filledLength);
+    console.log(
+      `📊 Usage: [${bar}] ${status.utilizationPercentage.toFixed(1)}%`
+    );
+    console.log("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n");
+  }
+
+  /**
+   * Test rate limits by making a series of requests using DuckAI (writes to shared store)
+   */
+  async testRateLimits(
+    numberOfRequests: number = 5,
+    delayBetweenRequests: number = 1000
+  ) {
+    console.log(
+      `🧪 Testing rate limits with ${numberOfRequests} requests (${delayBetweenRequests}ms delay)...`
+    );
+    console.log(
+      "📡 Using DuckAI class - data will be shared across processes!"
+    );
+
+    for (let i = 1; i <= numberOfRequests; i++) {
+      console.log(`\n📤 Making request ${i}/${numberOfRequests}...`);
+
+      try {
+        const startTime = Date.now();
+
+        const response = await this.duckAI.chat({
+          model: "gpt-4o-mini",
+          messages: [{ role: "user", content: `Shared test request ${i}` }],
+        });
+
+        const endTime = Date.now();
+        const responseTime = endTime - startTime;
+
+        console.log(`✅ Request ${i} successful (${responseTime}ms)`);
+        this.printStatus();
+
+        if (i < numberOfRequests) {
+          console.log(
+            `⏳ Waiting ${delayBetweenRequests}ms before next request...`
+          );
+          await new Promise((resolve) =>
+            setTimeout(resolve, delayBetweenRequests)
+          );
+        }
+      } catch (error) {
+        const errorMessage =
+          error instanceof Error ? error.message : String(error);
+        console.log(`❌ Request ${i} failed:`, errorMessage);
+        this.printStatus();
+
+        // If rate limited, wait longer
+        if (errorMessage.includes("Rate limited")) {
+          const waitTime =
+            this.getCurrentStatus().recommendedWaitTimeSeconds * 1000;
+          console.log(`⏳ Rate limited! Waiting ${waitTime}ms...`);
+          await new Promise((resolve) => setTimeout(resolve, waitTime));
+        }
+      }
+    }
+
+    console.log("\n🏁 Shared rate limit test completed!");
+    console.log(
+      "📡 Data has been written to shared store for cross-process monitoring!"
+    );
+  }
+
+  /**
+   * Get recommendations for optimal usage
+   */
+  getRecommendations() {
+    const status = this.getCurrentStatus();
+    const recommendations: string[] = [];
+
+    if (status.utilizationPercentage > 80) {
+      recommendations.push(
+        "⚠️  High utilization detected. Consider implementing request queuing."
+      );
+    }
+
+    if (status.recommendedWaitTimeSeconds > 0) {
+      recommendations.push(
+        `⏳ Wait ${status.recommendedWaitTimeSeconds}s before next request.`
+      );
+    }
+
+    if (status.isCurrentlyLimited) {
+      recommendations.push(
+        "🚫 Currently rate limited. Wait for window reset or implement exponential backoff."
+      );
+    }
+
+    if (status.utilizationPercentage < 50) {
+      recommendations.push(
+        "✅ Good utilization level. You can safely increase request frequency."
+      );
+    }
+
+    recommendations.push(
+      "💡 Consider implementing request batching for better efficiency."
+    );
+    recommendations.push("🔄 Use exponential backoff for retry logic.");
+    recommendations.push("📊 Monitor rate limits continuously in production.");
+    recommendations.push(
+      "📡 Use shared monitoring for cross-process visibility."
+    );
+
+    return recommendations;
+  }
+
+  /**
+   * Print recommendations
+   */
+  printRecommendations() {
+    const recommendations = this.getRecommendations();
+
+    console.log("\n💡 Rate Limit Recommendations:");
+    console.log("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
+    recommendations.forEach((rec) => console.log(rec));
+    console.log("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n");
+  }
+}
+
+// CLI usage
+if (require.main === module) {
+  const tester = new SharedRateLimitTester();
+
+  // Parse command line arguments
+  const args = process.argv.slice(2);
+  const command = args[0];
+
+  switch (command) {
+    case "status":
+      tester.printStatus();
+      tester.printRecommendations();
+      break;
+
+    case "test":
+      const requests = parseInt(args[1]) || 5;
+      const delay = parseInt(args[2]) || 1000;
+      tester.testRateLimits(requests, delay).then(() => {
+        tester.printRecommendations();
+        process.exit(0);
+      });
+      break;
+
+    default:
+      console.log("🔍 DuckAI Shared Rate Limit Tester");
+      console.log("📡 Uses DuckAI class - data is shared across processes!");
+      console.log("");
+      console.log("Usage:");
+      console.log(
+        "  bun run src/shared-rate-limit-tester.ts status                    # Show current status"
+      );
+      console.log(
+        "  bun run src/shared-rate-limit-tester.ts test [requests] [delay]  # Test rate limits (shared)"
+      );
+      console.log("");
+      console.log("Examples:");
+      console.log("  bun run src/shared-rate-limit-tester.ts status");
+      console.log("  bun run src/shared-rate-limit-tester.ts test 10 2000");
+      console.log("");
+      console.log("💡 For cross-process monitoring, run this in one terminal:");
+      console.log("  bun run src/shared-rate-limit-tester.ts test 20 3000");
+      console.log("");
+      console.log("And this in another terminal:");
+      console.log("  bun run src/shared-rate-limit-monitor.ts monitor 2");
+      break;
+  }
+}

start_duckai.bat

@@ -0,0 +1,29 @@
+@echo off
+REM DuckAI Server Starter
+REM Starts the DuckAI OpenAI-compatible server on port 3265
+
+echo Starting DuckAI Server...
+echo.
+
+REM Check if Node.js is installed
+where node >nul 2>nul
+if %ERRORLEVEL% neq 0 (
+    echo Node.js is not installed or not in PATH.
+    echo Please install Node.js from https://nodejs.org/
+    pause
+    exit /b 1
+)
+
+REM Change to DuckAI directory
+cd /d "%~dp0"
+
+REM Start DuckAI server
+echo Starting DuckAI OpenAI server on port 3265...
+echo Server will be available at: http://localhost:3265/v1
+echo.
+
+REM Run the server with port 3265
+set PORT=3265
+npm start
+
+pause

tool-service.ts

@@ -0,0 +1,288 @@
+import {
+  ToolDefinition,
+  ToolCall,
+  ToolChoice,
+  ChatCompletionMessage,
+  FunctionDefinition,
+} from "./types";
+
+export class ToolService {
+  /**
+   * Generates a system prompt that instructs the AI how to use the provided tools
+   */
+  generateToolSystemPrompt(
+    tools: ToolDefinition[],
+    toolChoice: ToolChoice = "auto"
+  ): string {
+    const toolDescriptions = tools
+      .map((tool) => {
+        const func = tool.function;
+        let description = `${func.name}`;
+
+        if (func.description) {
+          description += `: ${func.description}`;
+        }
+
+        if (func.parameters) {
+          const params = func.parameters.properties || {};
+          const required = func.parameters.required || [];
+
+          const paramDescriptions = Object.entries(params)
+            .map(([name, schema]: [string, any]) => {
+              const isRequired = required.includes(name);
+              const type = schema.type || "any";
+              const desc = schema.description || "";
+              return `  - ${name} (${type}${isRequired ? ", required" : ", optional"}): ${desc}`;
+            })
+            .join("\n");
+
+          if (paramDescriptions) {
+            description += `\nParameters:\n${paramDescriptions}`;
+          }
+        }
+
+        return description;
+      })
+      .join("\n\n");
+
+    let prompt = `You are an AI assistant with access to the following functions. When you need to call a function, respond with a JSON object in this exact format:
+
+{
+  "tool_calls": [
+    {
+      "id": "call_<unique_id>",
+      "type": "function",
+      "function": {
+        "name": "<function_name>",
+        "arguments": "<json_string_of_arguments>"
+      }
+    }
+  ]
+}
+
+Available functions:
+${toolDescriptions}
+
+Important rules:
+1. Only call functions when necessary to answer the user's question
+2. Use the exact function names provided
+3. Provide arguments as a JSON string
+4. Generate unique IDs for each tool call (e.g., call_1, call_2, etc.)
+5. If you don't need to call any functions, respond normally without the tool_calls format`;
+
+    if (toolChoice === "required") {
+      prompt +=
+        "\n6. You MUST call at least one function to answer this request";
+    } else if (toolChoice === "none") {
+      prompt += "\n6. Do NOT call any functions, respond normally";
+    } else if (
+      typeof toolChoice === "object" &&
+      toolChoice.type === "function"
+    ) {
+      prompt += `\n6. You MUST call the function "${toolChoice.function.name}"`;
+    }
+
+    return prompt;
+  }
+
+  /**
+   * Detects if a response contains function calls
+   */
+  detectFunctionCalls(content: string): boolean {
+    try {
+      const parsed = JSON.parse(content.trim());
+      return (
+        parsed.tool_calls &&
+        Array.isArray(parsed.tool_calls) &&
+        parsed.tool_calls.length > 0
+      );
+    } catch {
+      // Try to find tool_calls pattern in the text
+      return /["']?tool_calls["']?\s*:\s*\[/.test(content);
+    }
+  }
+
+  /**
+   * Extracts function calls from AI response
+   */
+  extractFunctionCalls(content: string): ToolCall[] {
+    try {
+      // First try to parse as complete JSON
+      const parsed = JSON.parse(content.trim());
+      if (parsed.tool_calls && Array.isArray(parsed.tool_calls)) {
+        return parsed.tool_calls.map((call: any, index: number) => ({
+          id: call.id || `call_${Date.now()}_${index}`,
+          type: "function",
+          function: {
+            name: call.function.name,
+            arguments:
+              typeof call.function.arguments === "string"
+                ? call.function.arguments
+                : JSON.stringify(call.function.arguments),
+          },
+        }));
+      }
+    } catch {
+      // Try to extract from partial or malformed JSON
+      const toolCallsMatch = content.match(
+        /["']?tool_calls["']?\s*:\s*\[(.*?)\]/s
+      );
+      if (toolCallsMatch) {
+        try {
+          const toolCallsStr = `[${toolCallsMatch[1]}]`;
+          const toolCalls = JSON.parse(toolCallsStr);
+          return toolCalls.map((call: any, index: number) => ({
+            id: call.id || `call_${Date.now()}_${index}`,
+            type: "function",
+            function: {
+              name: call.function.name,
+              arguments:
+                typeof call.function.arguments === "string"
+                  ? call.function.arguments
+                  : JSON.stringify(call.function.arguments),
+            },
+          }));
+        } catch {
+          // Fallback: try to extract individual function calls
+          return this.extractFunctionCallsFromText(content);
+        }
+      }
+    }
+
+    return [];
+  }
+
+  /**
+   * Fallback method to extract function calls from text
+   */
+  private extractFunctionCallsFromText(content: string): ToolCall[] {
+    const calls: ToolCall[] = [];
+
+    // Look for function call patterns
+    const functionPattern =
+      /["']?function["']?\s*:\s*\{[^}]*["']?name["']?\s*:\s*["']([^"']+)["'][^}]*["']?arguments["']?\s*:\s*["']([^"']*)["']/g;
+    let match;
+    let index = 0;
+
+    while ((match = functionPattern.exec(content)) !== null) {
+      calls.push({
+        id: `call_${Date.now()}_${index}`,
+        type: "function",
+        function: {
+          name: match[1],
+          arguments: match[2],
+        },
+      });
+      index++;
+    }
+
+    return calls;
+  }
+
+  /**
+   * Executes a function call (mock implementation - in real use, this would call actual functions)
+   */
+  async executeFunctionCall(
+    toolCall: ToolCall,
+    availableFunctions: Record<string, Function>
+  ): Promise<string> {
+    const functionName = toolCall.function.name;
+    const functionToCall = availableFunctions[functionName];
+
+    if (!functionToCall) {
+      return JSON.stringify({
+        error: `Function '${functionName}' not found`,
+        available_functions: Object.keys(availableFunctions),
+      });
+    }
+
+    try {
+      const args = JSON.parse(toolCall.function.arguments);
+      const result = await functionToCall(args);
+      return typeof result === "string" ? result : JSON.stringify(result);
+    } catch (error) {
+      return JSON.stringify({
+        error: `Error executing function '${functionName}': ${error instanceof Error ? error.message : "Unknown error"}`,
+        arguments_received: toolCall.function.arguments,
+      });
+    }
+  }
+
+  /**
+   * Creates a tool result message
+   */
+  createToolResultMessage(
+    toolCallId: string,
+    result: string
+  ): ChatCompletionMessage {
+    return {
+      role: "tool",
+      content: result,
+      tool_call_id: toolCallId,
+    };
+  }
+
+  /**
+   * Validates tool definitions
+   */
+  validateTools(tools: ToolDefinition[]): { valid: boolean; errors: string[] } {
+    const errors: string[] = [];
+
+    if (!Array.isArray(tools)) {
+      errors.push("Tools must be an array");
+      return { valid: false, errors };
+    }
+
+    tools.forEach((tool, index) => {
+      if (!tool.type || tool.type !== "function") {
+        errors.push(`Tool at index ${index}: type must be "function"`);
+      }
+
+      if (!tool.function) {
+        errors.push(`Tool at index ${index}: function definition is required`);
+        return;
+      }
+
+      if (!tool.function.name || typeof tool.function.name !== "string") {
+        errors.push(
+          `Tool at index ${index}: function name is required and must be a string`
+        );
+      }
+
+      if (tool.function.parameters) {
+        if (tool.function.parameters.type !== "object") {
+          errors.push(
+            `Tool at index ${index}: function parameters type must be "object"`
+          );
+        }
+      }
+    });
+
+    return { valid: errors.length === 0, errors };
+  }
+
+  /**
+   * Checks if the request requires function calling
+   */
+  shouldUseFunctionCalling(
+    tools?: ToolDefinition[],
+    toolChoice?: ToolChoice
+  ): boolean {
+    if (!tools || tools.length === 0) {
+      return false;
+    }
+
+    if (toolChoice === "none") {
+      return false;
+    }
+
+    return true;
+  }
+
+  /**
+   * Generates a unique ID for tool calls
+   */
+  generateToolCallId(): string {
+    return `call_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+  }
+}

types.ts

@@ -0,0 +1,112 @@
+// OpenAI API Types
+export interface ChatCompletionMessage {
+  role: "system" | "user" | "assistant" | "tool";
+  content: string | null;
+  name?: string;
+  tool_calls?: ToolCall[];
+  tool_call_id?: string;
+}
+
+export interface FunctionDefinition {
+  name: string;
+  description?: string;
+  parameters?: {
+    type: "object";
+    properties: Record<string, any>;
+    required?: string[];
+  };
+}
+
+export interface ToolDefinition {
+  type: "function";
+  function: FunctionDefinition;
+}
+
+export interface ToolCall {
+  id: string;
+  type: "function";
+  function: {
+    name: string;
+    arguments: string;
+  };
+}
+
+export type ToolChoice =
+  | "none"
+  | "auto"
+  | "required"
+  | { type: "function"; function: { name: string } };
+
+export interface ChatCompletionRequest {
+  model: string;
+  messages: ChatCompletionMessage[];
+  temperature?: number;
+  max_tokens?: number;
+  stream?: boolean;
+  top_p?: number;
+  frequency_penalty?: number;
+  presence_penalty?: number;
+  stop?: string | string[];
+  tools?: ToolDefinition[];
+  tool_choice?: ToolChoice;
+}
+
+export interface ChatCompletionChoice {
+  index: number;
+  message: ChatCompletionMessage;
+  finish_reason: "stop" | "length" | "content_filter" | "tool_calls" | null;
+}
+
+export interface ChatCompletionResponse {
+  id: string;
+  object: "chat.completion";
+  created: number;
+  model: string;
+  choices: ChatCompletionChoice[];
+  usage: {
+    prompt_tokens: number;
+    completion_tokens: number;
+    total_tokens: number;
+  };
+}
+
+export interface ChatCompletionStreamChoice {
+  index: number;
+  delta: {
+    role?: "assistant";
+    content?: string;
+    tool_calls?: ToolCall[];
+  };
+  finish_reason: "stop" | "length" | "content_filter" | "tool_calls" | null;
+}
+
+export interface ChatCompletionStreamResponse {
+  id: string;
+  object: "chat.completion.chunk";
+  created: number;
+  model: string;
+  choices: ChatCompletionStreamChoice[];
+}
+
+export interface Model {
+  id: string;
+  object: "model";
+  created: number;
+  owned_by: string;
+}
+
+export interface ModelsResponse {
+  object: "list";
+  data: Model[];
+}
+
+// Duck.ai specific types
+export interface VQDResponse {
+  vqd: string;
+  hash: string;
+}
+
+export interface DuckAIRequest {
+  model: string;
+  messages: ChatCompletionMessage[];
+}