@webwaka/core 1.3.0

package/src/core/ai/AIEngine.test.ts

@@ -0,0 +1,386 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { AIEngine } from './AIEngine';
+import { logger } from '../logger';
+
+// Mock fetch for OpenRouter
+global.fetch = vi.fn();
+
+/**
+ * Default engine uses maxRetries: 0 for the legacy three-tier fallback tests so
+ * that the existing behavior (single attempt per tier, no retries) is preserved.
+ * Retry-specific tests construct their own engine instances with maxRetries > 0.
+ */
+describe('CORE-5: AIEngine (Vendor Neutral AI)', () => {
+  let aiEngine: AIEngine;
+  let mockCloudflareAi: any;
+
+  beforeEach(() => {
+    vi.resetAllMocks();
+
+    mockCloudflareAi = {
+      run: vi.fn().mockResolvedValue({ response: 'Cloudflare AI response' }),
+    };
+
+    // maxRetries: 0 → single attempt per tier, matches the original test expectations.
+    aiEngine = new AIEngine('platform-key-123', mockCloudflareAi, { maxRetries: 0 });
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  // ─── Original three-tier fallback tests (no retries) ──────────────────────
+
+  it('should use Tenant BYOK when provided (Tier 1)', async () => {
+    (global.fetch as any).mockResolvedValueOnce({
+      ok: true,
+      json: async () => ({
+        choices: [{ message: { content: 'Tenant BYOK response' } }],
+      }),
+    });
+
+    const response = await aiEngine.execute(
+      { prompt: 'Hello', tenantId: 'tenant-1' },
+      { openRouterKey: 'tenant-key-456' }
+    );
+
+    expect(response.provider).toBe('tenant-openrouter');
+    expect(response.text).toBe('Tenant BYOK response');
+    expect(global.fetch).toHaveBeenCalledTimes(1);
+
+    const fetchArgs = (global.fetch as any).mock.calls[0];
+    expect(fetchArgs[1].headers['Authorization']).toBe('Bearer tenant-key-456');
+  });
+
+  it('should fallback to Platform Key if Tenant BYOK fails (Tier 2)', async () => {
+    // Tier 1 single attempt fails (maxRetries: 0)
+    (global.fetch as any).mockRejectedValueOnce(new Error('Network error'));
+
+    // Tier 2 single attempt succeeds
+    (global.fetch as any).mockResolvedValueOnce({
+      ok: true,
+      json: async () => ({
+        choices: [{ message: { content: 'Platform key response' } }],
+      }),
+    });
+
+    const response = await aiEngine.execute(
+      { prompt: 'Hello', tenantId: 'tenant-1' },
+      { openRouterKey: 'tenant-key-456' }
+    );
+
+    expect(response.provider).toBe('platform-openrouter');
+    expect(response.text).toBe('Platform key response');
+    expect(global.fetch).toHaveBeenCalledTimes(2);
+
+    const secondFetchArgs = (global.fetch as any).mock.calls[1];
+    expect(secondFetchArgs[1].headers['Authorization']).toBe('Bearer platform-key-123');
+  });
+
+  it('should fallback to Cloudflare AI if OpenRouter fails completely (Tier 3)', async () => {
+    // All fetch calls fail (Tier 1 + Tier 2, each 1 attempt with maxRetries: 0)
+    (global.fetch as any).mockRejectedValue(new Error('Network error'));
+
+    const response = await aiEngine.execute(
+      { prompt: 'Hello', tenantId: 'tenant-1' },
+      { openRouterKey: 'tenant-key-456' }
+    );
+
+    expect(response.provider).toBe('cloudflare-ai');
+    expect(response.text).toBe('Cloudflare AI response');
+    expect(mockCloudflareAi.run).toHaveBeenCalledTimes(1);
+  });
+
+  // ─── Retry / backoff tests ─────────────────────────────────────────────────
+
+  it('should retry within Tier 1 before succeeding (no tier escalation)', async () => {
+    // Engine with default maxRetries: 2
+    const retryEngine = new AIEngine('platform-key-123', mockCloudflareAi, {
+      maxRetries: 2,
+      backoffMs: 0, // zero delay for test speed
+    });
+
+    // Mock sleep to avoid real delays
+    vi.spyOn(retryEngine as any, 'sleep').mockResolvedValue(undefined);
+
+    // First two Tier 1 calls fail, third succeeds
+    (global.fetch as any)
+      .mockRejectedValueOnce(new Error('transient'))
+      .mockRejectedValueOnce(new Error('transient'))
+      .mockResolvedValueOnce({
+        ok: true,
+        json: async () => ({
+          choices: [{ message: { content: 'Retry success on Tier 1' } }],
+        }),
+      });
+
+    const response = await retryEngine.execute(
+      { prompt: 'Hello', tenantId: 'tenant-1' },
+      { openRouterKey: 'tenant-key-456' }
+    );
+
+    expect(response.provider).toBe('tenant-openrouter');
+    expect(response.text).toBe('Retry success on Tier 1');
+    // 3 fetch calls — all on Tier 1, no escalation to Tier 2
+    expect(global.fetch).toHaveBeenCalledTimes(3);
+    expect(mockCloudflareAi.run).not.toHaveBeenCalled();
+  });
+
+  it('should emit logger.warn for each retry attempt', async () => {
+    const retryEngine = new AIEngine('platform-key-123', mockCloudflareAi, {
+      maxRetries: 2,
+      backoffMs: 0,
+    });
+
+    vi.spyOn(retryEngine as any, 'sleep').mockResolvedValue(undefined);
+    const warnSpy = vi.spyOn(logger, 'warn');
+
+    // All Tier 1 attempts fail, Tier 2 first attempt succeeds
+    (global.fetch as any)
+      .mockRejectedValueOnce(new Error('fail'))
+      .mockRejectedValueOnce(new Error('fail'))
+      .mockRejectedValueOnce(new Error('fail'))
+      .mockResolvedValueOnce({
+        ok: true,
+        json: async () => ({
+          choices: [{ message: { content: 'Platform response' } }],
+        }),
+      });
+
+    const response = await retryEngine.execute(
+      { prompt: 'Test', tenantId: 'tenant-warn' },
+      { openRouterKey: 'tenant-key' }
+    );
+
+    expect(response.provider).toBe('platform-openrouter');
+    // logger.warn should have been called for retries + exhaustion
+    expect(warnSpy).toHaveBeenCalled();
+    const warnMessages = warnSpy.mock.calls.map(c => c[0]);
+    expect(warnMessages.some(m => m.includes('retry') || m.includes('exhausted'))).toBe(true);
+  });
+
+  it('should call sleep with exponential backoff delays between retries', async () => {
+    const retryEngine = new AIEngine('platform-key-123', mockCloudflareAi, {
+      maxRetries: 2,
+      backoffMs: 100,
+    });
+
+    const sleepSpy = vi.spyOn(retryEngine as any, 'sleep').mockResolvedValue(undefined);
+
+    // All Tier 1 attempts fail, Tier 2 succeeds immediately
+    (global.fetch as any)
+      .mockRejectedValueOnce(new Error('fail'))
+      .mockRejectedValueOnce(new Error('fail'))
+      .mockRejectedValueOnce(new Error('fail'))
+      .mockResolvedValueOnce({
+        ok: true,
+        json: async () => ({
+          choices: [{ message: { content: 'ok' } }],
+        }),
+      });
+
+    await retryEngine.execute(
+      { prompt: 'Test', tenantId: 't1' },
+      { openRouterKey: 'key' }
+    );
+
+    // Retries 1 and 2 within Tier 1: delays = 100*2^0=100ms, 100*2^1=200ms
+    const sleepCalls = sleepSpy.mock.calls.map(c => c[0]);
+    expect(sleepCalls).toContain(100);
+    expect(sleepCalls).toContain(200);
+  });
+
+  it('should retry within Tier 1, exhaust, then fall to Tier 2 and succeed', async () => {
+    const retryEngine = new AIEngine('platform-key-123', mockCloudflareAi, {
+      maxRetries: 1,
+      backoffMs: 0,
+    });
+
+    vi.spyOn(retryEngine as any, 'sleep').mockResolvedValue(undefined);
+
+    // Tier 1: 2 attempts (initial + 1 retry), both fail
+    // Tier 2: 1 attempt, succeeds
+    (global.fetch as any)
+      .mockRejectedValueOnce(new Error('fail'))
+      .mockRejectedValueOnce(new Error('fail'))
+      .mockResolvedValueOnce({
+        ok: true,
+        json: async () => ({
+          choices: [{ message: { content: 'Tier 2 after Tier 1 exhaustion' } }],
+        }),
+      });
+
+    const response = await retryEngine.execute(
+      { prompt: 'Hello', tenantId: 'tenant-1' },
+      { openRouterKey: 'tenant-key' }
+    );
+
+    expect(response.provider).toBe('platform-openrouter');
+    expect(response.text).toBe('Tier 2 after Tier 1 exhaustion');
+    expect(global.fetch).toHaveBeenCalledTimes(3);
+  });
+
+  it('should throw (and trigger retry/fallback) when OpenRouter returns malformed payload', async () => {
+    // Engine with maxRetries: 0 so it escalates immediately after one bad response
+    // Tier 1: returns HTTP 200 but with missing choices structure → should throw → fallback
+    (global.fetch as any).mockResolvedValueOnce({
+      ok: true,
+      json: async () => ({ result: 'unexpected shape' }), // no choices array
+    });
+
+    // Tier 2: also returns malformed payload → throws → escalates to Tier 3
+    (global.fetch as any).mockResolvedValueOnce({
+      ok: true,
+      json: async () => ({}), // completely empty
+    });
+
+    // Tier 3 CF AI succeeds
+    const response = await aiEngine.execute(
+      { prompt: 'Hello', tenantId: 'tenant-1' },
+      { openRouterKey: 'tenant-key-456' }
+    );
+
+    expect(response.provider).toBe('cloudflare-ai');
+    expect(mockCloudflareAi.run).toHaveBeenCalledTimes(1);
+  });
+
+  it('should retry Tier 1 on malformed payload before escalating (maxRetries: 1)', async () => {
+    const retryEngine = new AIEngine('platform-key-123', mockCloudflareAi, {
+      maxRetries: 1,
+      backoffMs: 0,
+    });
+    vi.spyOn(retryEngine as any, 'sleep').mockResolvedValue(undefined);
+
+    // Tier 1: attempt 1 → malformed, attempt 2 (retry) → valid
+    (global.fetch as any)
+      .mockResolvedValueOnce({
+        ok: true,
+        json: async () => ({ bad: 'payload' }),
+      })
+      .mockResolvedValueOnce({
+        ok: true,
+        json: async () => ({
+          choices: [{ message: { content: 'Recovered after retry' } }],
+        }),
+      });
+
+    const response = await retryEngine.execute(
+      { prompt: 'Hello', tenantId: 'tenant-1' },
+      { openRouterKey: 'tenant-key-456' }
+    );
+
+    expect(response.provider).toBe('tenant-openrouter');
+    expect(response.text).toBe('Recovered after retry');
+    expect(global.fetch).toHaveBeenCalledTimes(2);
+  });
+
+  // ─── executeStream tests ───────────────────────────────────────────────────
+
+  it('should return a ReadableStream from executeStream (Tier 1 success)', async () => {
+    const mockBody = new ReadableStream<Uint8Array>();
+
+    (global.fetch as any).mockResolvedValueOnce({
+      ok: true,
+      body: mockBody,
+    });
+
+    const stream = await aiEngine.executeStream(
+      { prompt: 'Stream test', tenantId: 'tenant-1' },
+      { openRouterKey: 'tenant-key-456' }
+    );
+
+    expect(stream).toBeInstanceOf(ReadableStream);
+    expect(stream).toBe(mockBody);
+  });
+
+  it('should include stream: true in the OpenRouter request body for executeStream', async () => {
+    const mockBody = new ReadableStream<Uint8Array>();
+
+    (global.fetch as any).mockResolvedValueOnce({ ok: true, body: mockBody });
+
+    await aiEngine.executeStream(
+      { prompt: 'Stream test', tenantId: 'tenant-1' },
+      { openRouterKey: 'tenant-key-456' }
+    );
+
+    const fetchCall = (global.fetch as any).mock.calls[0];
+    const bodyObj = JSON.parse(fetchCall[1].body);
+    expect(bodyObj.stream).toBe(true);
+  });
+
+  it('should fall back to Tier 2 stream if Tier 1 executeStream fails', async () => {
+    // maxRetries: 0 → single attempt per tier
+    const mockBody = new ReadableStream<Uint8Array>();
+
+    // Tier 1 fails
+    (global.fetch as any).mockRejectedValueOnce(new Error('Network error'));
+    // Tier 2 succeeds with streaming body
+    (global.fetch as any).mockResolvedValueOnce({ ok: true, body: mockBody });
+
+    const stream = await aiEngine.executeStream(
+      { prompt: 'Stream test', tenantId: 'tenant-1' },
+      { openRouterKey: 'tenant-key-456' }
+    );
+
+    expect(stream).toBeInstanceOf(ReadableStream);
+    expect(stream).toBe(mockBody);
+    expect(global.fetch).toHaveBeenCalledTimes(2);
+  });
+
+  it('should exhaust Tier 1 stream retries before falling to Tier 2 stream (maxRetries: 1)', async () => {
+    const retryEngine = new AIEngine('platform-key-123', mockCloudflareAi, {
+      maxRetries: 1,
+      backoffMs: 0,
+    });
+    vi.spyOn(retryEngine as any, 'sleep').mockResolvedValue(undefined);
+
+    const mockBody = new ReadableStream<Uint8Array>();
+
+    // Tier 1: 2 attempts (initial + 1 retry), both fail
+    (global.fetch as any)
+      .mockRejectedValueOnce(new Error('stream fail'))
+      .mockRejectedValueOnce(new Error('stream fail'))
+      // Tier 2: succeeds
+      .mockResolvedValueOnce({ ok: true, body: mockBody });
+
+    const stream = await retryEngine.executeStream(
+      { prompt: 'Hello', tenantId: 'tenant-1' },
+      { openRouterKey: 'tenant-key' }
+    );
+
+    expect(stream).toBeInstanceOf(ReadableStream);
+    expect(stream).toBe(mockBody);
+    expect(global.fetch).toHaveBeenCalledTimes(3);
+  });
+
+  it('should fall back to Cloudflare AI single-chunk stream if all OpenRouter stream attempts fail', async () => {
+    // maxRetries: 0 → both Tier 1 and Tier 2 fail on first attempt
+    (global.fetch as any).mockRejectedValue(new Error('Network error'));
+
+    const stream = await aiEngine.executeStream(
+      { prompt: 'Stream test', tenantId: 'tenant-1' },
+      { openRouterKey: 'tenant-key-456' }
+    );
+
+    expect(stream).toBeInstanceOf(ReadableStream);
+    expect(mockCloudflareAi.run).toHaveBeenCalledTimes(1);
+
+    // Read the single chunk and verify it contains the CF AI response text
+    const reader = stream.getReader();
+    const { value, done } = await reader.read();
+    expect(done).toBe(false);
+    expect(value).toBeInstanceOf(Uint8Array);
+    const text = new TextDecoder().decode(value);
+    expect(text).toBe('Cloudflare AI response');
+  });
+
+  it('should respect configurable maxRetries and backoffMs via constructor options', () => {
+    const customEngine = new AIEngine('key', mockCloudflareAi, {
+      maxRetries: 5,
+      backoffMs: 50,
+    });
+    // Access private fields via cast to validate constructor wiring
+    expect((customEngine as any).maxRetries).toBe(5);
+    expect((customEngine as any).backoffMs).toBe(50);
+  });
+});

package/src/core/ai/AIEngine.ts

@@ -0,0 +1,281 @@
+/**
+ * CORE-5: AI/BYOK Abstraction Engine
+ * Blueprint Reference: Part 9.1 #7 (Vendor Neutral AI)
+ *
+ * Implements a three-tier fallback mechanism with per-tier retry and exponential backoff:
+ *   1. Tenant BYOK (Bring Your Own Key) via OpenRouter
+ *   2. Platform Key via OpenRouter
+ *   3. Cloudflare Workers AI (Ultimate Fallback)
+ *
+ * Each tier is retried up to `maxRetries` times (default 2) before escalating.
+ * Between attempts the engine sleeps for backoffMs * 2^attempt milliseconds.
+ */
+
+import { logger } from '../logger';
+
+export interface AIRequest {
+  prompt: string;
+  model?: string;
+  tenantId: string;
+}
+
+export interface AIResponse {
+  text: string;
+  provider: 'tenant-openrouter' | 'platform-openrouter' | 'cloudflare-ai';
+  modelUsed: string;
+}
+
+export interface TenantConfig {
+  openRouterKey?: string;
+  preferredModel?: string;
+}
+
+export interface AIEngineOptions {
+  /** Maximum number of retry attempts per tier before escalating. Default: 2 */
+  maxRetries?: number;
+  /** Base delay in milliseconds for exponential backoff. Default: 200 */
+  backoffMs?: number;
+}
+
+export class AIEngine {
+  private platformOpenRouterKey: string;
+  private cloudflareAiBinding: any; // Type would be Ai from @cloudflare/workers-types
+  private maxRetries: number;
+  private backoffMs: number;
+
+  constructor(
+    platformOpenRouterKey: string,
+    cloudflareAiBinding: any,
+    options: AIEngineOptions = {}
+  ) {
+    this.platformOpenRouterKey = platformOpenRouterKey;
+    this.cloudflareAiBinding = cloudflareAiBinding;
+    this.maxRetries = options.maxRetries ?? 2;
+    this.backoffMs = options.backoffMs ?? 200;
+  }
+
+  /**
+   * Executes an AI request using the three-tier fallback strategy.
+   * Each tier is retried up to `maxRetries` times with exponential backoff
+   * before escalating to the next tier.
+   */
+  async execute(request: AIRequest, tenantConfig: TenantConfig): Promise<AIResponse> {
+    // Tier 1: Tenant BYOK via OpenRouter
+    if (tenantConfig.openRouterKey) {
+      const tier1Result = await this.withRetry(
+        'Tier 1 (tenant BYOK)',
+        request.tenantId,
+        () => this.callOpenRouter(
+          request.prompt,
+          tenantConfig.openRouterKey!,
+          request.model ?? tenantConfig.preferredModel ?? 'openai/gpt-4o-mini',
+          'tenant-openrouter'
+        )
+      );
+      if (tier1Result !== null) return tier1Result;
+    }
+
+    // Tier 2: Platform Key via OpenRouter
+    if (this.platformOpenRouterKey) {
+      const tier2Result = await this.withRetry(
+        'Tier 2 (platform key)',
+        request.tenantId,
+        () => this.callOpenRouter(
+          request.prompt,
+          this.platformOpenRouterKey,
+          request.model ?? 'openai/gpt-4o-mini',
+          'platform-openrouter'
+        )
+      );
+      if (tier2Result !== null) return tier2Result;
+    }
+
+    // Tier 3: Cloudflare Workers AI (Ultimate Fallback — no retry needed, CF AI is durable)
+    return await this.callCloudflareAI(request.prompt);
+  }
+
+  /**
+   * Executes an AI request and returns a ReadableStream<Uint8Array> for
+   * server-sent events streaming.
+   *
+   * - Tier 1 & 2: calls OpenRouter with `stream: true` and pipes `Response.body`.
+   * - Tier 3 (CF AI fallback): calls `execute()` and wraps the text in a
+   *   single-chunk ReadableStream (CF AI does not support streaming natively).
+   */
+  async executeStream(
+    request: AIRequest,
+    tenantConfig: TenantConfig
+  ): Promise<ReadableStream<Uint8Array>> {
+    // Tier 1: Tenant BYOK streaming
+    if (tenantConfig.openRouterKey) {
+      const tier1Result = await this.withRetry(
+        'Tier 1 stream (tenant BYOK)',
+        request.tenantId,
+        () => this.callOpenRouterStream(
+          request.prompt,
+          tenantConfig.openRouterKey!,
+          request.model ?? tenantConfig.preferredModel ?? 'openai/gpt-4o-mini'
+        )
+      );
+      if (tier1Result !== null) return tier1Result;
+    }
+
+    // Tier 2: Platform Key streaming
+    if (this.platformOpenRouterKey) {
+      const tier2Result = await this.withRetry(
+        'Tier 2 stream (platform key)',
+        request.tenantId,
+        () => this.callOpenRouterStream(
+          request.prompt,
+          this.platformOpenRouterKey,
+          request.model ?? 'openai/gpt-4o-mini'
+        )
+      );
+      if (tier2Result !== null) return tier2Result;
+    }
+
+    // Tier 3: Cloudflare AI — wrap non-streaming execute() result in a single-chunk stream
+    // (CF AI does not support native streaming; this keeps fallback logic in one place)
+    const fallback = await this.execute(request, tenantConfig);
+    const encoder = new TextEncoder();
+    const chunk = encoder.encode(fallback.text);
+    return new ReadableStream<Uint8Array>({
+      start(controller) {
+        controller.enqueue(chunk);
+        controller.close();
+      },
+    });
+  }
+
+  /**
+   * Runs `fn` up to `maxRetries + 1` times (1 initial attempt + maxRetries retries).
+   * Emits logger.warn on each retry. Returns the result on success, or null after
+   * exhausting all attempts (so the caller can escalate to the next tier).
+   */
+  private async withRetry<T>(
+    tierLabel: string,
+    tenantId: string,
+    fn: () => Promise<T>
+  ): Promise<T | null> {
+    let lastError: unknown;
+
+    for (let attempt = 0; attempt <= this.maxRetries; attempt++) {
+      if (attempt > 0) {
+        const delayMs = this.backoffMs * Math.pow(2, attempt - 1);
+        logger.warn(`${tierLabel} retry attempt ${attempt} after ${delayMs}ms`, {
+          tenantId,
+          attempt,
+          delayMs,
+        });
+        await this.sleep(delayMs);
+      }
+
+      try {
+        return await fn();
+      } catch (error) {
+        lastError = error;
+        if (attempt < this.maxRetries) {
+          logger.warn(`${tierLabel} attempt ${attempt + 1} failed, will retry`, {
+            tenantId,
+            attempt: attempt + 1,
+            error,
+          });
+        }
+      }
+    }
+
+    logger.warn(`${tierLabel} exhausted all ${this.maxRetries + 1} attempts, escalating`, {
+      tenantId,
+      error: lastError,
+    });
+    return null;
+  }
+
+  /**
+   * Delays execution for `ms` milliseconds.
+   * Defined as a protected method so tests can spy on it via vi.spyOn(engine, 'sleep').
+   */
+  protected sleep(ms: number): Promise<void> {
+    return new Promise(resolve => setTimeout(resolve, ms));
+  }
+
+  private async callOpenRouter(
+    prompt: string,
+    apiKey: string,
+    model: string,
+    provider: 'tenant-openrouter' | 'platform-openrouter'
+  ): Promise<AIResponse> {
+    const response = await fetch('https://openrouter.ai/api/v1/chat/completions', {
+      method: 'POST',
+      headers: {
+        'Authorization': `Bearer ${apiKey}`,
+        'Content-Type': 'application/json',
+        'HTTP-Referer': 'https://webwaka.com',
+        'X-Title': 'WebWaka OS v4',
+      },
+      body: JSON.stringify({
+        model,
+        messages: [{ role: 'user', content: prompt }],
+      }),
+    });
+
+    if (!response.ok) {
+      throw new Error(`OpenRouter API error: ${response.statusText}`);
+    }
+
+    const data = await response.json() as any;
+    const content: string | undefined = data.choices?.[0]?.message?.content;
+    if (typeof content !== 'string') {
+      throw new Error('OpenRouter returned an unexpected response structure (missing choices[0].message.content)');
+    }
+    return { text: content, provider, modelUsed: model };
+  }
+
+  private async callOpenRouterStream(
+    prompt: string,
+    apiKey: string,
+    model: string
+  ): Promise<ReadableStream<Uint8Array>> {
+    const response = await fetch('https://openrouter.ai/api/v1/chat/completions', {
+      method: 'POST',
+      headers: {
+        'Authorization': `Bearer ${apiKey}`,
+        'Content-Type': 'application/json',
+        'HTTP-Referer': 'https://webwaka.com',
+        'X-Title': 'WebWaka OS v4',
+      },
+      body: JSON.stringify({
+        model,
+        messages: [{ role: 'user', content: prompt }],
+        stream: true,
+      }),
+    });
+
+    if (!response.ok) {
+      throw new Error(`OpenRouter streaming API error: ${response.statusText}`);
+    }
+
+    if (!response.body) {
+      throw new Error('OpenRouter returned no response body for streaming request');
+    }
+
+    return response.body;
+  }
+
+  private async callCloudflareAI(prompt: string): Promise<AIResponse> {
+    if (!this.cloudflareAiBinding) {
+      throw new Error('Cloudflare AI binding not configured');
+    }
+
+    const model = '@cf/meta/llama-3-8b-instruct';
+    const response = await this.cloudflareAiBinding.run(model, {
+      messages: [{ role: 'user', content: prompt }],
+    });
+
+    return {
+      text: response.response,
+      provider: 'cloudflare-ai',
+      modelUsed: model,
+    };
+  }
+}