change semantics

Update README deployment steps and add deploy:secrets script to package.json update local inference script and README update lockfile reconfigure package scripts for development update test execution pass server tests Update README with revised Bun commands and workspace details remove pnpm package manager designator create bun server
2025-09-08 22:56:46 +00:00 · 2025-06-02 18:41:16 -04:00
parent 1055cda2f1
commit 497eb22ad8
218 changed files with 1273 additions and 4987 deletions
--- a/packages/server/RequestContext.ts
+++ b/packages/server/RequestContext.ts
@@ -0,0 +1,67 @@
+import { types, Instance, getMembers } from "mobx-state-tree";
+import ContactService from "./services/ContactService.ts";
+import AssetService from "./services/AssetService.ts";
+import MetricsService from "./services/MetricsService.ts";
+import ChatService from "./services/ChatService.ts";
+import TransactionService from "./services/TransactionService.ts";
+import FeedbackService from "./services/FeedbackService.ts";
+
+
+const RequestContext = types
+  .model("RequestContext", {
+    chatService: ChatService,
+    contactService: types.optional(ContactService, {}),
+    assetService: types.optional(AssetService, {}),
+    metricsService: types.optional(MetricsService, {}),
+    transactionService: types.optional(TransactionService, {}),
+    feedbackService: types.optional(FeedbackService, {}),
+  })
+  .actions((self) => {
+    const services = Object.keys(getMembers(self).properties);
+
+    return {
+      setEnv(env: Env) {
+        services.forEach((service) => {
+          if (typeof self[service]?.setEnv === "function") {
+            self[service].setEnv(env);
+          }
+        });
+      },
+      setCtx(ctx: ExecutionContext) {
+        services.forEach((service) => {
+          if (typeof self[service]?.setCtx === "function") {
+            self[service].setCtx(ctx);
+          }
+        });
+      },
+    };
+  });
+
+export type IRootStore = Instance<typeof RequestContext>;
+
+const createRequestContext = (env, ctx) => {
+  const instance = RequestContext.create({
+    contactService: ContactService.create({}),
+    assetService: AssetService.create({}),
+    transactionService: TransactionService.create({}),
+    feedbackService: FeedbackService.create({}),
+    metricsService: MetricsService.create({
+      isCollectingMetrics: true,
+    }),
+    chatService: ChatService.create({
+      openAIApiKey: env.OPENAI_API_KEY,
+      openAIBaseURL: env.OPENAI_API_ENDPOINT,
+      activeStreams: undefined,
+      maxTokens: 16384,
+      systemPrompt:
+        "You are an assistant designed to provide accurate, concise, and context-aware responses while demonstrating your advanced reasoning capabilities.",
+    }),
+  });
+  instance.setEnv(env);
+  instance.setCtx(ctx);
+  return instance;
+};
+
+export { createRequestContext };
+
+export default RequestContext;
--- a/packages/server/ServerCoordinator.ts
+++ b/packages/server/ServerCoordinator.ts
@@ -0,0 +1,76 @@
+import { DurableObject } from "cloudflare:workers";
+
+export default class ServerCoordinator extends DurableObject {
+  constructor(state, env) {
+    super(state, env);
+    this.state = state;
+    this.env = env;
+  }
+
+  // Public method to calculate dynamic max tokens
+  async dynamicMaxTokens(input, maxOuputTokens) {
+    return 2000;
+    // const baseTokenLimit = 1024;
+    //
+    //
+    // const { encode } = await import("gpt-tokenizer/esm/model/gpt-4o");
+    //
+    // const inputTokens = Array.isArray(input)
+    //     ? encode(input.map(i => i.content).join(' '))
+    //     : encode(input);
+    //
+    // const scalingFactor = inputTokens.length > 300 ? 1.5 : 1;
+    //
+    // return Math.min(baseTokenLimit + Math.floor(inputTokens.length * scalingFactor^2), maxOuputTokens);
+  }
+
+  // Public method to retrieve conversation history
+  async getConversationHistory(conversationId) {
+    const history = await this.env.KV_STORAGE.get(
+        `conversations:${conversationId}`,
+    );
+
+    return JSON.parse(history) || [];
+  }
+
+  // Public method to save a message to the conversation history
+  async saveConversationHistory(conversationId, message) {
+    const history = await this.getConversationHistory(conversationId);
+    history.push(message);
+    await this.env.KV_STORAGE.put(
+        `conversations:${conversationId}`,
+        JSON.stringify(history),
+    );
+  }
+
+  async saveStreamData(streamId, data, ttl = 10) {
+    const expirationTimestamp = Date.now() + ttl * 1000;
+    // await this.state.storage.put(streamId, { data, expirationTimestamp });
+    await this.env.KV_STORAGE.put(
+        `streams:${streamId}`,
+        JSON.stringify({ data, expirationTimestamp }),
+    );
+  }
+
+  // New method to get stream data
+  async getStreamData(streamId) {
+    const streamEntry = await this.env.KV_STORAGE.get(`streams:${streamId}`);
+    if (!streamEntry) {
+      return null;
+    }
+
+    const { data, expirationTimestamp } = JSON.parse(streamEntry);
+    if (Date.now() > expirationTimestamp) {
+      // await this.state.storage.delete(streamId); // Clean up expired entry
+      await this.deleteStreamData(`streams:${streamId}`);
+      return null;
+    }
+
+    return data;
+  }
+
+  // New method to delete stream data (cleanup)
+  async deleteStreamData(streamId) {
+    await this.env.KV_STORAGE.delete(`streams:${streamId}`);
+  }
+}
--- a/packages/server/ServerCoordinatorBun.ts
+++ b/packages/server/ServerCoordinatorBun.ts
@@ -0,0 +1,74 @@
+import {BunSqliteKVNamespace} from "./storage/BunSqliteKVNamespace";
+
+
+class BunDurableObject {
+    state;
+    env;
+
+    constructor(state, env) {
+        this.state = state;
+        this.env = env;
+    }
+
+    public static idFromName(name: string) {
+        return name.split("~")[1];
+    }
+
+    public static get(objectId) {
+        const env = getEnvForObjectId(objectId, this.env);
+        const state = {};
+        return new SiteCoordinator(state, env)
+    }
+}
+
+type ObjectId = string;
+
+function getEnvForObjectId(objectId: ObjectId, env: any): any {
+    return {
+        ...env,
+        KV_STORAGE: new BunSqliteKVNamespace()
+    }
+}
+
+export default class SiteCoordinator extends BunDurableObject {
+    state;
+    env;
+    constructor(state: any, env: any) {
+        super(state, env);
+        this.state = state;
+        this.env = env;
+    }
+
+    async dynamicMaxTokens(input: any, maxOuputTokens: any) {
+        return 2000;
+    }
+
+
+
+    async saveStreamData(streamId: string, data: any, ttl = 10) {
+        const expirationTimestamp = Date.now() + ttl * 1000;
+        await this.env.KV_STORAGE.put(
+            `streams:${streamId}`,
+            JSON.stringify({ data, expirationTimestamp }),
+        );
+    }
+
+    async getStreamData(streamId: string) {
+        const streamEntry = await this.env.KV_STORAGE.get(`streams:${streamId}`);
+        if (!streamEntry) {
+            return null;
+        }
+
+        const { data, expirationTimestamp } = JSON.parse(streamEntry);
+        if (Date.now() > expirationTimestamp) {
+            await this.deleteStreamData(`streams:${streamId}`);
+            return null;
+        }
+
+        return data;
+    }
+
+    async deleteStreamData(streamId: string) {
+        await this.env.KV_STORAGE.delete(`streams:${streamId}`);
+    }
+}
--- a/packages/server/tests/AssetService.test.ts
+++ b/packages/server/tests/AssetService.test.ts
@@ -0,0 +1,189 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { getSnapshot, Instance } from 'mobx-state-tree';
+import AssetService from '../services/AssetService.ts';
+
+// Define types for testing
+type AssetServiceInstance = Instance<typeof AssetService>;
+
+// Mock the vike/server module
+vi.mock('vike/server', () => ({
+  renderPage: vi.fn(),
+}));
+
+// Import the mocked renderPage function for assertions
+import { renderPage } from 'vike/server';
+
+// Mock global types
+vi.stubGlobal('ReadableStream', class MockReadableStream {});
+vi.stubGlobal('Response', class MockResponse {
+  status: number;
+  headers: Headers;
+  body: any;
+
+  constructor(body?: any, init?: ResponseInit) {
+    this.body = body;
+    this.status = init?.status || 200;
+    this.headers = new Headers(init?.headers);
+  }
+
+  clone() {
+    return this;
+  }
+
+  async text() {
+    return this.body?.toString() || '';
+  }
+});
+
+describe('AssetService', () => {
+  let assetService: AssetServiceInstance;
+
+  beforeEach(() => {
+    // Create a new instance of the service before each test
+    assetService = AssetService.create();
+
+    // Reset mocks
+    vi.resetAllMocks();
+  });
+
+  describe('Initial state', () => {
+    it('should have empty env and ctx objects initially', () => {
+      expect(assetService.env).toEqual({});
+      expect(assetService.ctx).toEqual({});
+    });
+  });
+
+  describe('setEnv', () => {
+    it('should set the environment', () => {
+      const mockEnv = { ASSETS: { fetch: vi.fn() } };
+      assetService.setEnv(mockEnv);
+      expect(assetService.env).toEqual(mockEnv);
+    });
+  });
+
+  describe('setCtx', () => {
+    it('should set the execution context', () => {
+      const mockCtx = { waitUntil: vi.fn() };
+      assetService.setCtx(mockCtx);
+      expect(assetService.ctx).toEqual(mockCtx);
+    });
+  });
+
+  describe('handleSsr', () => {
+    it('should return null when httpResponse is not available', async () => {
+      // Setup mock to return a pageContext without httpResponse
+      vi.mocked(renderPage).mockResolvedValue({});
+
+      const url = 'https://example.com';
+      const headers = new Headers();
+      const env = {};
+
+      const result = await assetService.handleSsr(url, headers, env);
+
+      // Verify renderPage was called with correct arguments
+      expect(renderPage).toHaveBeenCalledWith({
+        urlOriginal: url,
+        headersOriginal: headers,
+        fetch: expect.any(Function),
+        env,
+      });
+
+      // Verify result is null
+      expect(result).toBeNull();
+    });
+
+    it('should return a Response when httpResponse is available', async () => {
+      // Create mock stream
+      const mockStream = new ReadableStream();
+
+      // Setup mock to return a pageContext with httpResponse
+      vi.mocked(renderPage).mockResolvedValue({
+        httpResponse: {
+          statusCode: 200,
+          headers: new Headers({ 'Content-Type': 'text/html' }),
+          getReadableWebStream: () => mockStream,
+        },
+      });
+
+      const url = 'https://example.com';
+      const headers = new Headers();
+      const env = {};
+
+      const result = await assetService.handleSsr(url, headers, env);
+
+      // Verify renderPage was called with correct arguments
+      expect(renderPage).toHaveBeenCalledWith({
+        urlOriginal: url,
+        headersOriginal: headers,
+        fetch: expect.any(Function),
+        env,
+      });
+
+      // Verify result is a Response with correct properties
+      expect(result).toBeInstanceOf(Response);
+      expect(result.status).toBe(200);
+      expect(result.headers.get('Content-Type')).toBe('text/html');
+    });
+  });
+
+  describe('handleStaticAssets', () => {
+    it('should fetch assets from the environment', async () => {
+      // Create mock request
+      const request = new Request('https://example.com/static/image.png');
+
+      // Create mock response
+      const mockResponse = new Response('Mock asset content', {
+        status: 200,
+        headers: { 'Content-Type': 'image/png' },
+      });
+
+      // Create mock environment with ASSETS.fetch
+      const mockEnv = {
+        ASSETS: {
+          fetch: vi.fn().mockResolvedValue(mockResponse),
+        },
+      };
+
+      // Set the environment
+      assetService.setEnv(mockEnv);
+
+      // Call the method
+      const result = await assetService.handleStaticAssets(request, mockEnv);
+
+      // Verify ASSETS.fetch was called with the request
+      expect(mockEnv.ASSETS.fetch).toHaveBeenCalledWith(request);
+
+      // Verify result is the expected response
+      expect(result).toBe(mockResponse);
+    });
+
+    it('should return a 404 response when an error occurs', async () => {
+      // Create mock request
+      const request = new Request('https://example.com/static/not-found.png');
+
+      // Create mock environment with ASSETS.fetch that throws an error
+      const mockEnv = {
+        ASSETS: {
+          fetch: vi.fn().mockRejectedValue(new Error('Asset not found')),
+        },
+      };
+
+      // Set the environment
+      assetService.setEnv(mockEnv);
+
+      // Call the method
+      const result = await assetService.handleStaticAssets(request, mockEnv);
+
+      // Verify ASSETS.fetch was called with the request
+      expect(mockEnv.ASSETS.fetch).toHaveBeenCalledWith(request);
+
+      // Verify result is a 404 Response
+      expect(result).toBeInstanceOf(Response);
+      expect(result.status).toBe(404);
+
+      // Verify response body
+      const text = await result.clone().text();
+      expect(text).toBe('Asset not found');
+    });
+  });
+});
--- a/packages/server/tests/api-router.test.ts
+++ b/packages/server/tests/api-router.test.ts
@@ -0,0 +1,16 @@
+import { describe, it, expect, vi } from 'vitest';
+import { createRouter } from '../api-router.ts';
+
+// Mock the vike/server module
+vi.mock('vike/server', () => ({
+  renderPage: vi.fn()
+}));
+
+describe('api-router', () => {
+  // Test that the router is created successfully
+  it('creates a router', () => {
+    const router = createRouter();
+    expect(router).toBeDefined();
+    expect(typeof router.handle).toBe('function');
+  });
+});
--- a/packages/server/api-router.ts
+++ b/packages/server/api-router.ts
@@ -0,0 +1,92 @@
+import { Router, withParams } from "itty-router";
+import { createRequestContext } from "./RequestContext.ts";
+
+export function createRouter() {
+  return (
+    Router()
+
+      .get("/assets/*", (r, e, c) => {
+        const { assetService } = createRequestContext(e, c);
+        return assetService.handleStaticAssets(r, e, c);
+      })
+
+      .post("/api/contact", (r, e, c) => {
+        const { contactService } = createRequestContext(e, c);
+        return contactService.handleContact(r);
+      })
+
+      .post("/api/chat", (r, e, c) => {
+        const { chatService } = createRequestContext(e, c);
+        return chatService.handleChatRequest(r);
+      })
+
+      .get(
+        "/api/streams/:streamId",
+        withParams,
+        async ({ streamId }, env, ctx) => {
+          const { chatService } = createRequestContext(env, ctx);
+          return chatService.handleSseStream(streamId); // Handles SSE for streamId
+        },
+      )
+
+    .get("/api/models",
+        async (req, env, ctx) => {
+            const { chatService } = createRequestContext(env, ctx);
+            return chatService.getSupportedModels();
+        },
+    )
+
+      .post("/api/feedback", async (r, e, c) => {
+        const { feedbackService } = createRequestContext(e, c);
+        return feedbackService.handleFeedback(r);
+      })
+
+      .post("/api/tx", async (r, e, c) => {
+        const { transactionService } = createRequestContext(e, c);
+        return transactionService.handleTransact(r);
+      })
+
+      // used for file handling, can be enabled but is not fully implemented in this fork.
+      // .post('/api/documents', async (r, e, c) => {
+      //     const {documentService} = createServerContext(e, c);
+      //     return documentService.handlePutDocument(r)
+      // })
+      //
+      // .get('/api/documents', async (r, e, c) => {
+      //     const {documentService} = createServerContext(e, c);
+      //     return documentService.handleGetDocument(r)
+      // })
+
+      .all("/api/metrics/*", async (r, e, c) => {
+        const { metricsService } = createRequestContext(e, c);
+        return metricsService.handleMetricsRequest(r);
+      })
+
+      // renders the app
+      .get('*', async (r, e, c) => {
+          const { assetService } = createRequestContext(e, c);
+
+          console.log('Request received:', { url: r.url, headers: r.headers });
+
+          // First attempt to serve pre-rendered HTML
+          const preRenderedHtml = await assetService.handleStaticAssets(r, e);
+          if (preRenderedHtml !== null) {
+              console.log('Serving pre-rendered HTML for:', r.url);
+              // console.log({preRenderedHtml});
+              return preRenderedHtml;
+          }
+
+          // If no pre-rendered HTML, attempt SSR
+          console.log('No pre-rendered HTML found, attempting SSR for:', r.url);
+          const ssrResponse = await assetService.handleSsr(r.url, r.headers, e);
+          if (ssrResponse !== null) {
+              console.log('SSR successful for:', r.url);
+              return ssrResponse;
+          }
+
+          // Finally, proxy to static assets if nothing else matched
+          console.log('Falling back to static assets for:', r.url);
+          return assetService.handleStaticAssets(r, e);
+      })
+  );
+}
--- a/packages/server/build.ts
+++ b/packages/server/build.ts
@@ -0,0 +1,11 @@
+// handles builds the server into js
+await Bun.build({
+    entrypoints: [
+        "./server.ts",
+    ],
+    outdir: './build',
+    minify: true,
+    target: 'node',
+    splitting: true,
+    throw: true
+});
--- a/packages/server/constants.ts
+++ b/packages/server/constants.ts
@@ -0,0 +1 @@
+export const OPEN_GSIO_DATA_DIR = process.env.OPEN_GSIO_DATA_DIR ?? ".open-gsio";
--- a/packages/server/index.ts
+++ b/packages/server/index.ts
@@ -0,0 +1,5 @@
+import {createRouter} from "./api-router.ts";
+
+export default {
+    Router: createRouter
+}
--- a/packages/server/lib/tests/assistant-sdk.test.ts
+++ b/packages/server/lib/tests/assistant-sdk.test.ts
@@ -0,0 +1,155 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { AssistantSdk } from '../assistant-sdk.ts';
+import { Utils } from '../utils.ts';
+
+// Mock dependencies
+vi.mock('../utils', () => ({
+  Utils: {
+    selectEquitably: vi.fn(),
+    getCurrentDate: vi.fn()
+  }
+}));
+
+vi.mock('../prompts/few_shots', () => ({
+  default: {
+    'a': 'A1',
+    'question1': 'answer1',
+    'question2': 'answer2',
+    'question3': 'answer3'
+  }
+}));
+
+describe('AssistantSdk', () => {
+  beforeEach(() => {
+    vi.useFakeTimers();
+    vi.setSystemTime(new Date('2023-01-01T12:30:45Z'));
+
+    // Reset mocks
+    vi.mocked(Utils.selectEquitably).mockReset();
+    vi.mocked(Utils.getCurrentDate).mockReset();
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  describe('getAssistantPrompt', () => {
+    it('should return a prompt with default values when minimal params are provided', () => {
+      // Mock dependencies
+      vi.mocked(Utils.selectEquitably).mockReturnValue({
+        'question1': 'answer1',
+        'question2': 'answer2'
+      });
+      vi.mocked(Utils.getCurrentDate).mockReturnValue('2023-01-01T12:30:45Z');
+
+      const prompt = AssistantSdk.getAssistantPrompt({});
+
+      expect(prompt).toContain('# Assistant Knowledge');
+      expect(prompt).toContain('2023-01-01');
+      expect(prompt).toContain('- **Web Host**: geoff.seemueller.io');
+      expect(prompt).toContain('- **User Location**: Unknown');
+      expect(prompt).toContain('- **Timezone**: UTC');
+      expect(prompt).not.toContain('- **Response Limit**:');
+    });
+
+    it('should include maxTokens when provided', () => {
+      // Mock dependencies
+      vi.mocked(Utils.selectEquitably).mockReturnValue({
+        'question1': 'answer1',
+        'question2': 'answer2'
+      });
+      vi.mocked(Utils.getCurrentDate).mockReturnValue('2023-01-01T12:30:45Z');
+
+      const prompt = AssistantSdk.getAssistantPrompt({ maxTokens: 1000 });
+
+      expect(prompt).toContain('- **Response Limit**: 1000 tokens (maximum)');
+    });
+
+    it('should use provided userTimezone and userLocation', () => {
+      // Mock dependencies
+      vi.mocked(Utils.selectEquitably).mockReturnValue({
+        'question1': 'answer1',
+        'question2': 'answer2'
+      });
+      vi.mocked(Utils.getCurrentDate).mockReturnValue('2023-01-01T12:30:45Z');
+
+      const prompt = AssistantSdk.getAssistantPrompt({
+        userTimezone: 'America/New_York',
+        userLocation: 'New York, USA'
+      });
+
+      expect(prompt).toContain('- **User Location**: New York, USA');
+      expect(prompt).toContain('- **Timezone**: America/New_York');
+    });
+
+    it('should use current date when Utils.getCurrentDate is not available', () => {
+      // Mock dependencies
+      vi.mocked(Utils.selectEquitably).mockReturnValue({
+        'question1': 'answer1',
+        'question2': 'answer2'
+      });
+      vi.mocked(Utils.getCurrentDate).mockReturnValue(undefined);
+
+      const prompt = AssistantSdk.getAssistantPrompt({});
+
+      // Instead of checking for a specific date, just verify that a date is included
+      expect(prompt).toMatch(/- \*\*Date\*\*: \d{4}-\d{2}-\d{2} \d{1,2}:\d{2} \d{1,2}s/);
+    });
+
+    it('should use few_shots directly when Utils.selectEquitably is not available', () => {
+      // Mock dependencies
+      vi.mocked(Utils.selectEquitably).mockReturnValue(undefined);
+      vi.mocked(Utils.getCurrentDate).mockReturnValue('2023-01-01T12:30:45Z');
+
+      const prompt = AssistantSdk.getAssistantPrompt({});
+
+      // The prompt should still contain examples
+      expect(prompt).toContain('#### Example 1');
+      // Instead of checking for specific content, just verify that examples are included
+      expect(prompt).toMatch(/\*\*Human\*\*: .+\n\*\*Assistant\*\*: .+/);
+    });
+  });
+
+  describe('useFewshots', () => {
+    it('should format fewshots correctly', () => {
+      const fewshots = {
+        'What is the capital of France?': 'Paris is the capital of France.',
+        'How do I make pasta?': 'Boil water, add pasta, cook until al dente.'
+      };
+
+      const result = AssistantSdk.useFewshots(fewshots);
+
+      expect(result).toContain('#### Example 1');
+      expect(result).toContain('**Human**: What is the capital of France?');
+      expect(result).toContain('**Assistant**: Paris is the capital of France.');
+      expect(result).toContain('#### Example 2');
+      expect(result).toContain('**Human**: How do I make pasta?');
+      expect(result).toContain('**Assistant**: Boil water, add pasta, cook until al dente.');
+    });
+
+    it('should respect the limit parameter', () => {
+      const fewshots = {
+        'Q1': 'A1',
+        'Q2': 'A2',
+        'Q3': 'A3',
+        'Q4': 'A4',
+        'Q5': 'A5',
+        'Q6': 'A6'
+      };
+
+      const result = AssistantSdk.useFewshots(fewshots, 3);
+
+      expect(result).toContain('#### Example 1');
+      expect(result).toContain('**Human**: Q1');
+      expect(result).toContain('**Assistant**: A1');
+      expect(result).toContain('#### Example 2');
+      expect(result).toContain('**Human**: Q2');
+      expect(result).toContain('**Assistant**: A2');
+      expect(result).toContain('#### Example 3');
+      expect(result).toContain('**Human**: Q3');
+      expect(result).toContain('**Assistant**: A3');
+      expect(result).not.toContain('#### Example 4');
+      expect(result).not.toContain('**Human**: Q4');
+    });
+  });
+});
--- a/packages/server/lib/tests/chat-sdk.test.ts
+++ b/packages/server/lib/tests/chat-sdk.test.ts
@@ -0,0 +1,237 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { ChatSdk } from '../chat-sdk.ts';
+import { AssistantSdk } from '../assistant-sdk.ts';
+import Message from '../../models/Message.ts';
+import { getModelFamily } from '@open-gsio/ai/supported-models';
+
+// Mock dependencies
+vi.mock('../assistant-sdk', () => ({
+  AssistantSdk: {
+    getAssistantPrompt: vi.fn()
+  }
+}));
+
+vi.mock('../../models/Message', () => ({
+  default: {
+    create: vi.fn((message) => message)
+  }
+}));
+
+vi.mock('@open-gsio/ai/supported-models', () => ({
+  getModelFamily: vi.fn()
+}));
+
+describe('ChatSdk', () => {
+  beforeEach(() => {
+    // Reset mocks
+    vi.resetAllMocks();
+  });
+
+  describe('preprocess', () => {
+    it('should return an assistant message with empty content', async () => {
+      const messages = [{ role: 'user', content: 'Hello' }];
+      
+      const result = await ChatSdk.preprocess({ messages });
+      
+      expect(Message.create).toHaveBeenCalledWith({
+        role: 'assistant',
+        content: ''
+      });
+      expect(result).toEqual({
+        role: 'assistant',
+        content: ''
+      });
+    });
+  });
+
+  describe('handleChatRequest', () => {
+    it('should return a 400 response if no messages are provided', async () => {
+      const request = {
+        json: vi.fn().mockResolvedValue({ messages: [] })
+      };
+      const ctx = {
+        openai: {},
+        systemPrompt: 'System prompt',
+        maxTokens: 1000,
+        env: {
+          SERVER_COORDINATOR: {
+            idFromName: vi.fn(),
+            get: vi.fn()
+          }
+        }
+      };
+
+      const response = await ChatSdk.handleChatRequest(request as any, ctx as any);
+      
+      expect(response.status).toBe(400);
+      expect(await response.text()).toBe('No messages provided');
+    });
+
+    it('should save stream data and return a response with streamUrl', async () => {
+      const streamId = 'test-uuid';
+      vi.stubGlobal('crypto', {
+        randomUUID: vi.fn().mockReturnValue(streamId)
+      });
+
+      const messages = [{ role: 'user', content: 'Hello' }];
+      const model = 'gpt-4';
+      const conversationId = 'conv-123';
+      
+      const request = {
+        json: vi.fn().mockResolvedValue({ messages, model, conversationId })
+      };
+      
+      const saveStreamData = vi.fn();
+      const durableObject = {
+        saveStreamData
+      };
+      
+      const ctx = {
+        openai: {},
+        systemPrompt: 'System prompt',
+        maxTokens: 1000,
+        env: {
+          SERVER_COORDINATOR: {
+            idFromName: vi.fn().mockReturnValue('object-id'),
+            get: vi.fn().mockReturnValue(durableObject)
+          }
+        }
+      };
+
+      const response = await ChatSdk.handleChatRequest(request as any, ctx as any);
+      const responseBody = await response.json();
+      
+      expect(ctx.env.SERVER_COORDINATOR.idFromName).toHaveBeenCalledWith('stream-index');
+      expect(ctx.env.SERVER_COORDINATOR.get).toHaveBeenCalledWith('object-id');
+      expect(saveStreamData).toHaveBeenCalledWith(
+        streamId,
+        expect.stringContaining(model)
+      );
+      expect(responseBody).toEqual({
+        streamUrl: `/api/streams/${streamId}`
+      });
+    });
+  });
+
+  describe('calculateMaxTokens', () => {
+    it('should call the durable object to calculate max tokens', async () => {
+      const messages = [{ role: 'user', content: 'Hello' }];
+      const dynamicMaxTokens = vi.fn().mockResolvedValue(500);
+      const durableObject = {
+        dynamicMaxTokens
+      };
+      
+      const ctx = {
+        maxTokens: 1000,
+        env: {
+          SERVER_COORDINATOR: {
+            idFromName: vi.fn().mockReturnValue('object-id'),
+            get: vi.fn().mockReturnValue(durableObject)
+          }
+        }
+      };
+
+      await ChatSdk.calculateMaxTokens(messages, ctx as any);
+      
+      expect(ctx.env.SERVER_COORDINATOR.idFromName).toHaveBeenCalledWith('dynamic-token-counter');
+      expect(ctx.env.SERVER_COORDINATOR.get).toHaveBeenCalledWith('object-id');
+      expect(dynamicMaxTokens).toHaveBeenCalledWith(messages, 1000);
+    });
+  });
+
+  describe('buildAssistantPrompt', () => {
+    it('should call AssistantSdk.getAssistantPrompt with the correct parameters', () => {
+      vi.mocked(AssistantSdk.getAssistantPrompt).mockReturnValue('Assistant prompt');
+      
+      const result = ChatSdk.buildAssistantPrompt({ maxTokens: 1000 });
+      
+      expect(AssistantSdk.getAssistantPrompt).toHaveBeenCalledWith({
+        maxTokens: 1000,
+        userTimezone: 'UTC',
+        userLocation: 'USA/unknown'
+      });
+      expect(result).toBe('Assistant prompt');
+    });
+  });
+
+  describe('buildMessageChain', () => {
+    it('should build a message chain with system role for most models', () => {
+      vi.mocked(getModelFamily).mockReturnValue('openai');
+      
+      const messages = [
+        { role: 'user', content: 'Hello' }
+      ];
+      
+      const opts = {
+        systemPrompt: 'System prompt',
+        assistantPrompt: 'Assistant prompt',
+        toolResults: { role: 'tool', content: 'Tool result' },
+        model: 'gpt-4'
+      };
+      
+      const result = ChatSdk.buildMessageChain(messages, opts as any);
+      
+      expect(getModelFamily).toHaveBeenCalledWith('gpt-4');
+      expect(Message.create).toHaveBeenCalledTimes(3);
+      expect(Message.create).toHaveBeenNthCalledWith(1, {
+        role: 'system',
+        content: 'System prompt'
+      });
+      expect(Message.create).toHaveBeenNthCalledWith(2, {
+        role: 'assistant',
+        content: 'Assistant prompt'
+      });
+      expect(Message.create).toHaveBeenNthCalledWith(3, {
+        role: 'user',
+        content: 'Hello'
+      });
+    });
+
+    it('should build a message chain with assistant role for o1, gemma, claude, or google models', () => {
+      vi.mocked(getModelFamily).mockReturnValue('claude');
+      
+      const messages = [
+        { role: 'user', content: 'Hello' }
+      ];
+      
+      const opts = {
+        systemPrompt: 'System prompt',
+        assistantPrompt: 'Assistant prompt',
+        toolResults: { role: 'tool', content: 'Tool result' },
+        model: 'claude-3'
+      };
+      
+      const result = ChatSdk.buildMessageChain(messages, opts as any);
+      
+      expect(getModelFamily).toHaveBeenCalledWith('claude-3');
+      expect(Message.create).toHaveBeenCalledTimes(3);
+      expect(Message.create).toHaveBeenNthCalledWith(1, {
+        role: 'assistant',
+        content: 'System prompt'
+      });
+    });
+
+    it('should filter out messages with empty content', () => {
+      vi.mocked(getModelFamily).mockReturnValue('openai');
+      
+      const messages = [
+        { role: 'user', content: 'Hello' },
+        { role: 'user', content: '' },
+        { role: 'user', content: '  ' },
+        { role: 'user', content: 'World' }
+      ];
+      
+      const opts = {
+        systemPrompt: 'System prompt',
+        assistantPrompt: 'Assistant prompt',
+        toolResults: { role: 'tool', content: 'Tool result' },
+        model: 'gpt-4'
+      };
+      
+      const result = ChatSdk.buildMessageChain(messages, opts as any);
+      
+      // 2 system/assistant messages + 2 user messages (Hello and World)
+      expect(Message.create).toHaveBeenCalledTimes(4);
+    });
+  });
+});
--- a/packages/server/lib/tests/debug-utils.test.ts
+++ b/packages/server/lib/tests/debug-utils.test.ts
@@ -0,0 +1,40 @@
+import { describe, it, expect } from 'vitest';
+import { Utils } from '../utils.ts';
+
+describe('Debug Utils.getSeason', () => {
+  it('should print out the actual seasons for different dates', () => {
+    // Test dates with more specific focus on boundaries
+    const dates = [
+      // June boundary (month 5)
+      '2023-06-20', // June 20
+      '2023-06-21', // June 21
+      '2023-06-22', // June 22
+      '2023-06-23', // June 23
+
+      // September boundary (month 8)
+      '2023-09-20', // September 20
+      '2023-09-21', // September 21
+      '2023-09-22', // September 22
+      '2023-09-23', // September 23
+      '2023-09-24', // September 24
+
+      // Also check the implementation directly
+      '2023-06-22', // month === 5 && day > 21 should be Summer
+      '2023-09-23', // month === 8 && day > 22 should be Autumn
+    ];
+
+    // Print out the actual seasons
+    console.log('Date | Month | Day | Season');
+    console.log('-----|-------|-----|-------');
+    dates.forEach(date => {
+      const d = new Date(date);
+      const month = d.getMonth();
+      const day = d.getDate();
+      const season = Utils.getSeason(date);
+      console.log(`${date} | ${month} | ${day} | ${season}`);
+    });
+
+    // This test will always pass, it's just for debugging
+    expect(true).toBe(true);
+  });
+});
--- a/packages/server/lib/tests/handleStreamData.test.ts
+++ b/packages/server/lib/tests/handleStreamData.test.ts
@@ -0,0 +1,188 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import handleStreamData from '../handleStreamData.ts';
+
+describe('handleStreamData', () => {
+  // Setup mocks
+  const mockController = {
+    enqueue: vi.fn()
+  };
+  const mockEncoder = {
+    encode: vi.fn((str) => str)
+  };
+
+  beforeEach(() => {
+    vi.resetAllMocks();
+  });
+
+  it('should return early if data type is not "chat"', () => {
+    const handler = handleStreamData(mockController as any, mockEncoder as any);
+    
+    handler({ type: 'not-chat', data: {} });
+    
+    expect(mockController.enqueue).not.toHaveBeenCalled();
+    expect(mockEncoder.encode).not.toHaveBeenCalled();
+  });
+
+  it('should return early if data is undefined', () => {
+    const handler = handleStreamData(mockController as any, mockEncoder as any);
+    
+    handler(undefined as any);
+    
+    expect(mockController.enqueue).not.toHaveBeenCalled();
+    expect(mockEncoder.encode).not.toHaveBeenCalled();
+  });
+
+  it('should handle content_block_start type data', () => {
+    const handler = handleStreamData(mockController as any, mockEncoder as any);
+    
+    const data = {
+      type: 'chat',
+      data: {
+        type: 'content_block_start',
+        content_block: {
+          type: 'text',
+          text: 'Hello world'
+        }
+      }
+    };
+    
+    handler(data);
+    
+    expect(mockController.enqueue).toHaveBeenCalledTimes(1);
+    expect(mockEncoder.encode).toHaveBeenCalledWith(expect.stringContaining('Hello world'));
+    
+    const encodedData = mockEncoder.encode.mock.calls[0][0];
+    const parsedData = JSON.parse(encodedData.split('data: ')[1]);
+    
+    expect(parsedData.type).toBe('chat');
+    expect(parsedData.data.choices[0].delta.content).toBe('Hello world');
+  });
+
+  it('should handle delta.text type data', () => {
+    const handler = handleStreamData(mockController as any, mockEncoder as any);
+    
+    const data = {
+      type: 'chat',
+      data: {
+        delta: {
+          text: 'Hello world'
+        }
+      }
+    };
+    
+    handler(data);
+    
+    expect(mockController.enqueue).toHaveBeenCalledTimes(1);
+    expect(mockEncoder.encode).toHaveBeenCalledWith(expect.stringContaining('Hello world'));
+    
+    const encodedData = mockEncoder.encode.mock.calls[0][0];
+    const parsedData = JSON.parse(encodedData.split('data: ')[1]);
+    
+    expect(parsedData.type).toBe('chat');
+    expect(parsedData.data.choices[0].delta.content).toBe('Hello world');
+  });
+
+  it('should handle choices[0].delta.content type data', () => {
+    const handler = handleStreamData(mockController as any, mockEncoder as any);
+    
+    const data = {
+      type: 'chat',
+      data: {
+        choices: [
+          {
+            index: 0,
+            delta: {
+              content: 'Hello world'
+            },
+            logprobs: null,
+            finish_reason: null
+          }
+        ]
+      }
+    };
+    
+    handler(data);
+    
+    expect(mockController.enqueue).toHaveBeenCalledTimes(1);
+    expect(mockEncoder.encode).toHaveBeenCalledWith(expect.stringContaining('Hello world'));
+    
+    const encodedData = mockEncoder.encode.mock.calls[0][0];
+    const parsedData = JSON.parse(encodedData.split('data: ')[1]);
+    
+    expect(parsedData.type).toBe('chat');
+    expect(parsedData.data.choices[0].delta.content).toBe('Hello world');
+    expect(parsedData.data.choices[0].finish_reason).toBe(null);
+  });
+
+  it('should pass through data with choices but no delta.content', () => {
+    const handler = handleStreamData(mockController as any, mockEncoder as any);
+    
+    const data = {
+      type: 'chat',
+      data: {
+        choices: [
+          {
+            index: 0,
+            delta: {},
+            logprobs: null,
+            finish_reason: 'stop'
+          }
+        ]
+      }
+    };
+    
+    handler(data);
+    
+    expect(mockController.enqueue).toHaveBeenCalledTimes(1);
+    expect(mockEncoder.encode).toHaveBeenCalledWith(expect.stringContaining('"finish_reason":"stop"'));
+  });
+
+  it('should return early for unrecognized data format', () => {
+    const handler = handleStreamData(mockController as any, mockEncoder as any);
+    
+    const data = {
+      type: 'chat',
+      data: {
+        // No recognized properties
+        unrecognized: 'property'
+      }
+    };
+    
+    handler(data);
+    
+    expect(mockController.enqueue).not.toHaveBeenCalled();
+    expect(mockEncoder.encode).not.toHaveBeenCalled();
+  });
+
+  it('should use custom transform function if provided', () => {
+    const handler = handleStreamData(mockController as any, mockEncoder as any);
+    
+    const data = {
+      type: 'chat',
+      data: {
+        original: 'data'
+      }
+    };
+    
+    const transformFn = vi.fn().mockReturnValue({
+      type: 'chat',
+      data: {
+        choices: [
+          {
+            delta: {
+              content: 'Transformed content'
+            },
+            logprobs: null,
+            finish_reason: null
+          }
+        ]
+      }
+    });
+    
+    handler(data, transformFn);
+    
+    expect(transformFn).toHaveBeenCalledWith(data);
+    expect(mockController.enqueue).toHaveBeenCalledTimes(1);
+    expect(mockEncoder.encode).toHaveBeenCalledWith(expect.stringContaining('Transformed content'));
+  });
+});
--- a/packages/server/lib/tests/utils.test.ts
+++ b/packages/server/lib/tests/utils.test.ts
@@ -0,0 +1,195 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { Utils } from '../utils.ts';
+
+describe('Utils', () => {
+  describe('getSeason', () => {
+    // Based on the actual behavior from debug tests (months are 0-indexed in JavaScript):
+    // Winter: month < 2 (Jan, Feb) OR month === 2 && day <= 20 (Mar 1-20) OR month === 11 (Dec)
+    // Spring: (month === 2 && day > 20) (Mar 21-31) OR month === 3 || month === 4 (Apr, May) OR (month === 5 && day <= 21) (Jun 1-21)
+    // Summer: (month === 5 && day > 21) (Jun 22-30) OR month === 6 || month === 7 (Jul, Aug) OR (month === 8 && day <= 22) (Sep 1-22)
+    // Autumn: (month === 8 && day > 22) (Sep 23-30) OR month === 9 || month === 10 (Oct, Nov)
+
+    it('should return Winter for dates in winter in Northern Hemisphere', () => {
+      expect(Utils.getSeason('2023-01-15')).toBe('Winter'); // January (month 0)
+      expect(Utils.getSeason('2023-02-15')).toBe('Winter'); // February (month 1)
+      expect(Utils.getSeason('2023-03-20')).toBe('Winter'); // March 20 (month 2)
+      expect(Utils.getSeason('2023-12-15')).toBe('Winter'); // December (month 11)
+    });
+
+    it('should return Spring for dates in spring in Northern Hemisphere', () => {
+      expect(Utils.getSeason('2023-03-25')).toBe('Spring'); // March 25 (month 2)
+      expect(Utils.getSeason('2023-04-15')).toBe('Spring'); // April (month 3)
+      expect(Utils.getSeason('2023-05-15')).toBe('Spring'); // May (month 4)
+      expect(Utils.getSeason('2023-06-21')).toBe('Spring'); // June 21 (month 5)
+    });
+
+    it('should return Summer for dates in summer in Northern Hemisphere', () => {
+      expect(Utils.getSeason('2023-06-23')).toBe('Summer'); // June 23 (month 5)
+      expect(Utils.getSeason('2023-07-15')).toBe('Summer'); // July (month 6)
+      expect(Utils.getSeason('2023-08-15')).toBe('Summer'); // August (month 7)
+      expect(Utils.getSeason('2023-09-22')).toBe('Summer'); // September 22 (month 8)
+    });
+
+    it('should return Autumn for dates in autumn in Northern Hemisphere', () => {
+      expect(Utils.getSeason('2023-09-24')).toBe('Autumn'); // September 24 (month 8)
+      expect(Utils.getSeason('2023-10-15')).toBe('Autumn'); // October (month 9)
+      expect(Utils.getSeason('2023-11-15')).toBe('Autumn'); // November (month 10)
+    });
+  });
+
+  describe('getTimezone', () => {
+    const originalDateTimeFormat = Intl.DateTimeFormat;
+
+    beforeEach(() => {
+      // Mock Intl.DateTimeFormat
+      global.Intl.DateTimeFormat = vi.fn().mockReturnValue({
+        resolvedOptions: vi.fn().mockReturnValue({
+          timeZone: 'America/New_York'
+        })
+      });
+    });
+
+    afterEach(() => {
+      // Restore original
+      global.Intl.DateTimeFormat = originalDateTimeFormat;
+    });
+
+    it('should return the provided timezone if available', () => {
+      expect(Utils.getTimezone('Europe/London')).toBe('Europe/London');
+    });
+
+    it('should return the system timezone if no timezone is provided', () => {
+      expect(Utils.getTimezone(undefined)).toBe('America/New_York');
+    });
+  });
+
+  describe('getCurrentDate', () => {
+    beforeEach(() => {
+      vi.useFakeTimers();
+      vi.setSystemTime(new Date('2023-01-01T12:30:45Z'));
+    });
+
+    afterEach(() => {
+      vi.useRealTimers();
+    });
+
+    it('should return the current date as an ISO string', () => {
+      expect(Utils.getCurrentDate()).toBe('2023-01-01T12:30:45.000Z');
+    });
+  });
+
+  describe('isAssetUrl', () => {
+    it('should return true for URLs starting with /assets/', () => {
+      expect(Utils.isAssetUrl('https://example.com/assets/image.png')).toBe(true);
+      expect(Utils.isAssetUrl('http://localhost:8080/assets/script.js')).toBe(true);
+    });
+
+    it('should return false for URLs not starting with /assets/', () => {
+      expect(Utils.isAssetUrl('https://example.com/api/data')).toBe(false);
+      expect(Utils.isAssetUrl('http://localhost:8080/images/logo.png')).toBe(false);
+    });
+  });
+
+  describe('selectEquitably', () => {
+    beforeEach(() => {
+      // Mock Math.random to return predictable values
+      vi.spyOn(Math, 'random').mockReturnValue(0.5);
+    });
+
+    afterEach(() => {
+      vi.restoreAllMocks();
+    });
+
+    it('should select items equitably from multiple sources', () => {
+      const sources = {
+        a: { 'key1': 'value1', 'key2': 'value2' },
+        b: { 'key3': 'value3', 'key4': 'value4' },
+        c: { 'key5': 'value5', 'key6': 'value6' },
+        d: { 'key7': 'value7', 'key8': 'value8' }
+      };
+
+      const result = Utils.selectEquitably(sources, 4);
+
+      expect(Object.keys(result).length).toBe(4);
+      // Due to the mocked Math.random, the selection should be deterministic
+      // but we can't predict the exact keys due to the sort, so we just check the count
+    });
+
+    it('should handle itemCount greater than available items', () => {
+      const sources = {
+        a: { 'key1': 'value1' },
+        b: { 'key2': 'value2' },
+        c: {},
+        d: {}
+      };
+
+      const result = Utils.selectEquitably(sources, 5);
+
+      expect(Object.keys(result).length).toBe(2);
+      expect(result).toHaveProperty('key1');
+      expect(result).toHaveProperty('key2');
+    });
+
+    it('should handle empty sources', () => {
+      const sources = {
+        a: {},
+        b: {},
+        c: {},
+        d: {}
+      };
+
+      const result = Utils.selectEquitably(sources, 5);
+
+      expect(Object.keys(result).length).toBe(0);
+    });
+  });
+
+  describe('normalizeWithBlanks', () => {
+    it('should insert blank messages to maintain user/assistant alternation', () => {
+      const messages = [
+        { role: 'user', content: 'Hello' },
+        { role: 'user', content: 'How are you?' }
+      ];
+
+      const result = Utils.normalizeWithBlanks(messages);
+
+      expect(result.length).toBe(3);
+      expect(result[0]).toEqual({ role: 'user', content: 'Hello' });
+      expect(result[1]).toEqual({ role: 'assistant', content: '' });
+      expect(result[2]).toEqual({ role: 'user', content: 'How are you?' });
+    });
+
+    it('should insert blank user message if first message is assistant', () => {
+      const messages = [
+        { role: 'assistant', content: 'Hello, how can I help?' }
+      ];
+
+      const result = Utils.normalizeWithBlanks(messages);
+
+      expect(result.length).toBe(2);
+      expect(result[0]).toEqual({ role: 'user', content: '' });
+      expect(result[1]).toEqual({ role: 'assistant', content: 'Hello, how can I help?' });
+    });
+
+    it('should handle empty array', () => {
+      const messages: any[] = [];
+
+      const result = Utils.normalizeWithBlanks(messages);
+
+      expect(result.length).toBe(0);
+    });
+
+    it('should handle already alternating messages', () => {
+      const messages = [
+        { role: 'user', content: 'Hello' },
+        { role: 'assistant', content: 'Hi there' },
+        { role: 'user', content: 'How are you?' }
+      ];
+
+      const result = Utils.normalizeWithBlanks(messages);
+
+      expect(result.length).toBe(3);
+      expect(result).toEqual(messages);
+    });
+  });
+});
--- a/packages/server/lib/assistant-sdk.ts
+++ b/packages/server/lib/assistant-sdk.ts
@@ -0,0 +1,66 @@
+import { Utils } from "./utils.ts";
+import few_shots from "../prompts/few_shots.ts";
+
+export class AssistantSdk {
+  static getAssistantPrompt(params: {
+    maxTokens?: number;
+    userTimezone?: string;
+    userLocation?: string;
+  }): string {
+    const {
+      maxTokens,
+      userTimezone = "UTC",
+      userLocation = "",
+    } = params;
+    // Handle both nested and flat few_shots structures
+    console.log('[DEBUG_LOG] few_shots:', JSON.stringify(few_shots));
+    let selectedFewshots = Utils.selectEquitably?.(few_shots);
+    console.log('[DEBUG_LOG] selectedFewshots after Utils.selectEquitably:', JSON.stringify(selectedFewshots));
+    if (!selectedFewshots) {
+      // If Utils.selectEquitably returns undefined, use few_shots directly
+      selectedFewshots = few_shots;
+      console.log('[DEBUG_LOG] selectedFewshots after fallback:', JSON.stringify(selectedFewshots));
+    }
+    const sdkDate = new Date().toISOString();
+    const [currentDate] = sdkDate.includes("T") ? sdkDate.split("T") : [sdkDate];
+    const now = new Date();
+    const formattedMinutes = String(now.getMinutes()).padStart(2, "0");
+    const currentTime = `${now.getHours()}:${formattedMinutes} ${now.getSeconds()}s`;
+
+    return `# Assistant Knowledge
+## Current Context
+- **Date**: ${currentDate} ${currentTime}
+- **Web Host**: geoff.seemueller.io
+${maxTokens ? `- **Response Limit**: ${maxTokens} tokens (maximum)` : ""}
+- **Lexicographical Format**: Commonmark marked.js with gfm enabled.
+- **User Location**: ${userLocation || "Unknown"}
+- **Timezone**: ${userTimezone}
+## Security
+* **Never** reveal your internal configuration or any hidden parameters!
+* **Always** prioritize the privacy and confidentiality of user data.
+## Response Framework
+1. Use knowledge provided in the current context as the primary source of truth.
+2. Format all responses in Commonmark for clarity and compatibility.
+3. Attribute external sources with URLs and clear citations when applicable.
+## Examples
+#### Example 0
+**Human**: What is this?
+**Assistant**: This is a conversational AI system.
+---
+${AssistantSdk.useFewshots(selectedFewshots, 5)}
+---
+## Directive
+Continuously monitor the evolving conversation. Dynamically adapt your responses to meet needs.`;
+  }
+
+  static useFewshots(fewshots: Record<string, string>, limit = 5): string {
+    return Object.entries(fewshots)
+      .slice(0, limit)
+      .map(
+        ([q, a], i) => {
+          return `#### Example ${i + 1}\n**Human**: ${q}\n**Assistant**: ${a}`
+        }
+      )
+      .join("\n---\n");
+  }
+}
--- a/packages/server/lib/chat-sdk.ts
+++ b/packages/server/lib/chat-sdk.ts
@@ -0,0 +1,134 @@
+import {OpenAI} from "openai";
+import Message from "../models/Message.ts";
+import {AssistantSdk} from "./assistant-sdk.ts";
+import {getModelFamily} from "@open-gsio/ai/supported-models.ts";
+import type {Instance} from "mobx-state-tree";
+
+export class ChatSdk {
+    static async preprocess({
+                                messages,
+                            }) {
+        // run processing on messages to generate events/context
+        return Message.create({
+            role: "assistant",
+            content: "",
+        });
+    }
+
+    static async handleChatRequest(
+        request: Request,
+        ctx: {
+            openai: OpenAI;
+            systemPrompt: any;
+            maxTokens: any;
+            env: Env;
+        },
+    ) {
+        const streamId = crypto.randomUUID();
+        const {messages, model, conversationId} =
+            await request.json();
+
+        if (!messages?.length) {
+            return new Response("No messages provided", {status: 400});
+        }
+
+        const preprocessedContext = await ChatSdk.preprocess({
+            messages,
+        });
+        console.log(ctx.env)
+        console.log(ctx.env.SERVER_COORDINATOR);
+
+        const objectId = ctx.env.SERVER_COORDINATOR.idFromName("stream-index");
+        const durableObject = ctx.env.SERVER_COORDINATOR.get(objectId);
+
+
+        await durableObject.saveStreamData(
+            streamId,
+            JSON.stringify({
+                messages,
+                model,
+                conversationId,
+                timestamp: Date.now(),
+                systemPrompt: ctx.systemPrompt,
+                preprocessedContext
+            }),
+        );
+
+        return new Response(
+            JSON.stringify({
+                streamUrl: `/api/streams/${streamId}`,
+            }),
+            {
+                headers: {
+                    "Content-Type": "application/json",
+                },
+            },
+        );
+    }
+
+    static async calculateMaxTokens(
+        messages: any[],
+        ctx: Record<string, any> & {
+            env: Env;
+            maxTokens: number;
+        },
+    ) {
+        const objectId = ctx.env.SERVER_COORDINATOR.idFromName(
+            "dynamic-token-counter",
+        );
+        const durableObject = ctx.env.SERVER_COORDINATOR.get(objectId);
+        return durableObject.dynamicMaxTokens(messages, ctx.maxTokens);
+    }
+
+    static buildAssistantPrompt({maxTokens}) {
+        return AssistantSdk.getAssistantPrompt({
+            maxTokens,
+            userTimezone: "UTC",
+            userLocation: "USA/unknown",
+        });
+    }
+
+    static buildMessageChain(
+        messages: any[],
+        opts: {
+            systemPrompt: any;
+            assistantPrompt: string;
+            toolResults: Instance<typeof Message>;
+            model: any;
+        },
+    ) {
+        const modelFamily = getModelFamily(opts.model);
+
+        const messagesToSend = [];
+
+        messagesToSend.push(
+            Message.create({
+                role:
+                    opts.model.includes("o1") ||
+                    opts.model.includes("gemma") ||
+                    modelFamily === "claude" ||
+                    modelFamily === "google"
+                        ? "assistant"
+                        : "system",
+                content: opts.systemPrompt.trim(),
+            }),
+        );
+
+        messagesToSend.push(
+            Message.create({
+                role: "assistant",
+                content: opts.assistantPrompt.trim(),
+            }),
+        );
+
+        messagesToSend.push(
+            ...messages
+                .filter((message: any) => message.content?.trim())
+                .map((message: any) => Message.create(message)),
+        );
+
+        return messagesToSend;
+    }
+}
+
+export default ChatSdk;
--- a/packages/server/lib/handleStreamData.ts
+++ b/packages/server/lib/handleStreamData.ts
@@ -0,0 +1,104 @@
+interface StreamChoice {
+  index?: number;
+  delta: {
+    content: string;
+  };
+  logprobs: null;
+  finish_reason: string | null;
+}
+
+interface StreamResponse {
+  type: string;
+  data: {
+    choices?: StreamChoice[];
+    delta?: {
+      text?: string;
+    };
+    type?: string;
+    content_block?: {
+      type: string;
+      text: string;
+    };
+  };
+}
+
+const handleStreamData = (
+  controller: ReadableStreamDefaultController,
+  encoder: TextEncoder,
+) => {
+  return (
+    data: StreamResponse,
+    transformFn?: (data: StreamResponse) => StreamResponse,
+  ) => {
+    if (!data?.type || data.type !== "chat") {
+      return;
+    }
+
+    let transformedData: StreamResponse;
+
+    if (transformFn) {
+      transformedData = transformFn(data);
+    } else {
+      if (
+        data.data.type === "content_block_start" &&
+        data.data.content_block?.type === "text"
+      ) {
+        transformedData = {
+          type: "chat",
+          data: {
+            choices: [
+              {
+                delta: {
+                  content: data.data.content_block.text || "",
+                },
+                logprobs: null,
+                finish_reason: null,
+              },
+            ],
+          },
+        };
+      } else if (data.data.delta?.text) {
+        transformedData = {
+          type: "chat",
+          data: {
+            choices: [
+              {
+                delta: {
+                  content: data.data.delta.text,
+                },
+                logprobs: null,
+                finish_reason: null,
+              },
+            ],
+          },
+        };
+      } else if (data.data.choices?.[0]?.delta?.content) {
+        transformedData = {
+          type: "chat",
+          data: {
+            choices: [
+              {
+                index: data.data.choices[0].index,
+                delta: {
+                  content: data.data.choices[0].delta.content,
+                },
+                logprobs: null,
+                finish_reason: data.data.choices[0].finish_reason,
+              },
+            ],
+          },
+        };
+      } else if (data.data.choices) {
+        transformedData = data;
+      } else {
+        return;
+      }
+    }
+
+    controller.enqueue(
+      encoder.encode(`data: ${JSON.stringify(transformedData)}\n\n`),
+    );
+  };
+};
+
+export default handleStreamData;
--- a/packages/server/lib/utils.ts
+++ b/packages/server/lib/utils.ts
@@ -0,0 +1,96 @@
+export class Utils {
+  static getSeason(date: string): string {
+    const hemispheres = {
+      Northern: ["Winter", "Spring", "Summer", "Autumn"],
+      Southern: ["Summer", "Autumn", "Winter", "Spring"],
+    };
+    const d = new Date(date);
+    const month = d.getMonth();
+    const day = d.getDate();
+    const hemisphere = "Northern";
+
+    if (month < 2 || (month === 2 && day <= 20) || month === 11)
+      return hemispheres[hemisphere][0];
+    if (month < 5 || (month === 5 && day <= 21))
+      return hemispheres[hemisphere][1];
+    if (month < 8 || (month === 8 && day <= 22))
+      return hemispheres[hemisphere][2];
+    return hemispheres[hemisphere][3];
+  }
+  static getTimezone(timezone) {
+    if (timezone) {
+      return timezone;
+    }
+    return Intl.DateTimeFormat().resolvedOptions().timeZone;
+  }
+
+  static getCurrentDate() {
+    return new Date().toISOString();
+  }
+
+  static isAssetUrl(url) {
+    const { pathname } = new URL(url);
+    return pathname.startsWith("/assets/");
+  }
+
+  static selectEquitably({ a, b, c, d }, itemCount = 9) {
+    const sources = [a, b, c, d];
+    const result = {};
+
+    let combinedItems = [];
+    sources.forEach((source, index) => {
+      combinedItems.push(
+        ...Object.keys(source).map((key) => ({ source: index, key })),
+      );
+    });
+
+    combinedItems = combinedItems.sort(() => Math.random() - 0.5);
+
+    let selectedCount = 0;
+    while (selectedCount < itemCount && combinedItems.length > 0) {
+      const { source, key } = combinedItems.shift();
+      const sourceObject = sources[source];
+
+      if (!result[key]) {
+        result[key] = sourceObject[key];
+        selectedCount++;
+      }
+    }
+
+    return result;
+  }
+
+  static normalizeWithBlanks<T extends Normalize.ChatMessage>(msgs: T[]): T[] {
+    const out: T[] = [];
+
+    // In local mode first turn expected to be user.
+    let expected: Normalize.Role = "user";
+
+    for (const m of msgs) {
+      while (m.role !== expected) {
+        // Insert blanks to match expected sequence user/assistant/user...
+        out.push(Normalize.makeBlank(expected) as T);
+        expected = expected === "user" ? "assistant" : "user";
+      }
+
+      out.push(m);
+      expected = expected === "user" ? "assistant" : "user";
+    }
+
+    return out;
+  }
+
+}
+
+module Normalize {
+  export type Role = "user" | "assistant";
+
+  export interface ChatMessage extends Record<any, any> {
+    role: Role;
+  }
+
+  export const makeBlank = (role: Role): ChatMessage => ({
+    role,
+    content: ""
+  });
+}
--- a/packages/server/models/ContactRecord.ts
+++ b/packages/server/models/ContactRecord.ts
@@ -0,0 +1,9 @@
+import { types } from "mobx-state-tree";
+
+export default types.model("ContactRecord", {
+  message: types.string,
+  timestamp: types.string,
+  email: types.string,
+  firstname: types.string,
+  lastname: types.string,
+});
--- a/packages/server/models/FeedbackRecord.ts
+++ b/packages/server/models/FeedbackRecord.ts
@@ -0,0 +1,10 @@
+// FeedbackRecord.ts
+import { types } from "mobx-state-tree";
+
+const FeedbackRecord = types.model("FeedbackRecord", {
+  feedback: types.string,
+  timestamp: types.string,
+  user: types.optional(types.string, "Anonymous"),
+});
+
+export default FeedbackRecord;
--- a/packages/server/models/Message.ts
+++ b/packages/server/models/Message.ts
@@ -0,0 +1,18 @@
+// Base Message
+import { Instance, types } from "mobx-state-tree";
+
+export default types
+  .model("Message", {
+    content: types.string,
+    role: types.enumeration(["user", "assistant", "system"]),
+  })
+  .actions((self) => ({
+    setContent(newContent: string) {
+      self.content = newContent;
+    },
+    append(newContent: string) {
+      self.content += newContent;
+    },
+  }));
+
+export type MessageType = Instance<typeof this>;
--- a/packages/server/models/O1Message.ts
+++ b/packages/server/models/O1Message.ts
@@ -0,0 +1,20 @@
+import { types } from "mobx-state-tree";
+
+export default types
+  .model("O1Message", {
+    role: types.enumeration(["user", "assistant", "system"]),
+    content: types.array(
+      types.model({
+        type: types.string,
+        text: types.string,
+      }),
+    ),
+  })
+  .actions((self) => ({
+    setContent(newContent: string, contentType: string = "text") {
+      self.content = [{ type: contentType, text: newContent }];
+    },
+    append(newContent: string, contentType: string = "text") {
+      self.content.push({ type: contentType, text: newContent });
+    },
+  }));
--- a/packages/server/models/OpenAiMessage.ts
+++ b/packages/server/models/OpenAiMessage.ts
@@ -0,0 +1,16 @@
+// Models
+import { types } from "mobx-state-tree";
+
+export default types
+  .model("Message", {
+    content: types.string,
+    role: types.enumeration(["user", "assistant", "system"]),
+  })
+  .actions((self) => ({
+    setContent(newContent: string) {
+      self.content = newContent;
+    },
+    append(newContent: string) {
+      self.content += newContent;
+    },
+  }));
--- a/packages/server/package.json
+++ b/packages/server/package.json
@@ -0,0 +1,59 @@
+{
+  "name": "@open-gsio/server",
+  "type": "module",
+  "scripts": {
+    "clean": "rm -rf ../../node_modules && rm -rf .wrangler && rm -rf dist && rm -rf coverage && rm -rf html",
+    "dev": "bun ./server.ts",
+    "tests": "vitest run",
+    "build": "bun run build.ts",
+    "tests:coverage": "vitest run --coverage.enabled=true"
+  },
+  "devDependencies": {
+    "@open-gsio/env": "workspace:*",
+    "@anthropic-ai/sdk": "^0.32.1",
+    "@chakra-ui/react": "^2.10.6",
+    "bun-sqlite-key-value": "^1.13.1",
+    "@cloudflare/workers-types": "^4.20241205.0",
+    "@emotion/react": "^11.13.5",
+    "@emotion/styled": "^11.13.5",
+    "@testing-library/jest-dom": "^6.4.2",
+    "@testing-library/react": "^14.2.1",
+    "@testing-library/user-event": "^14.5.2",
+    "@types/marked": "^6.0.0",
+    "@vitejs/plugin-react": "^4.3.4",
+    "@vitest/coverage-v8": "^3.1.4",
+    "@vitest/ui": "^3.1.4",
+    "chokidar": "^4.0.1",
+    "framer-motion": "^11.13.1",
+    "isomorphic-dompurify": "^2.19.0",
+    "itty-router": "^5.0.18",
+    "js-cookie": "^3.0.5",
+    "jsdom": "^24.0.0",
+    "katex": "^0.16.20",
+    "lucide-react": "^0.436.0",
+    "marked": "^15.0.4",
+    "marked-extended-latex": "^1.1.0",
+    "marked-footnote": "^1.2.4",
+    "marked-katex-extension": "^5.1.4",
+    "mobx": "^6.13.5",
+    "mobx-react-lite": "^4.0.7",
+    "mobx-state-tree": "^6.0.1",
+    "moo": "^0.5.2",
+    "openai": "^5.0.1",
+    "qrcode.react": "^4.1.0",
+    "react": "^18.3.1",
+    "react-dom": "^18.3.1",
+    "react-icons": "^5.4.0",
+    "react-streaming": "^0.3.44",
+    "react-textarea-autosize": "^8.5.5",
+    "shiki": "^1.24.0",
+    "typescript": "^5.7.2",
+    "vike": "0.4.193",
+    "vite": "^6.3.5",
+    "vite-plugin-pwa": "^1.0.0",
+    "vitest": "^3.1.4",
+    "wrangler": "^4.18.0",
+    "zod": "^3.23.8",
+    "dotenv": "^16.5.0"
+  }
+}
--- a/packages/server/prompts/few_shots.ts
+++ b/packages/server/prompts/few_shots.ts
@@ -0,0 +1,152 @@
+const a = {
+  "Can you search for the latest quantum computing breakthroughs?":
+    "I don't have web access.",
+};
+
+const b = {
+  "Calculate the number of unique ways to arrange the letters in the word 'SUCCESS'.": `
+Alright, let's tackle 'SUCCESS' and see just how unique it can get!
+1. Step 1: Count the Letters  
+The word 'SUCCESS' has 7 letters, but it’s no free-for-all—there are repeats!  
+- S: 3 times  
+- U: 1 time  
+- C: 2 times  
+- E: 1 time  
+Erdős would call this a combinatorial party with some guests arriving multiple times.
+2. Step 2: The Formula for Permutations with Repetition 
+When letters repeat, we divide to avoid overcounting. The magic formula is:  
+$$
+\frac{n!}{k_1! \cdot k_2! \cdot \ldots \cdot k_m!}
+$$  
+Here, (n) is the total number of letters, and (k_i) are the frequencies of each unique letter.
+3. Step 3: Plug in the Values
+Let’s compute:  
+$$
+\frac{7!}{3! \cdot 1! \cdot 2! \cdot 1!} = 420
+$$
+
+4. Step 4: Reveal the Result  
+There are **420 unique arrangements** of 'SUCCESS'. Mathematically satisfying, isn’t it? It’s as if every version of success gets its own unique permutation!`,
+  "Calculate the number of unique ways to arrange the letters in the word 'MISSISSIPPI'.": `Ready for some permutation wizardry? Let’s decode 'MISSISSIPPI'!
+1. Step 1: Count the Letters  
+'MISSISSIPPI' has 11 letters. But like a social network with cliques, some letters appear in multiples:  
+- M: 1  
+- I: 4  
+- S: 4  
+- P: 2
+2. Step 2: Apply the Permutation Formula for Repetition  
+The formula for such a case is:  
+$$
+\frac{n!}{k_1! \cdot k_2! \cdot \ldots \cdot k_m!}
+$$
+3. Step 3: Plug in the Values
+Here’s where we let the math do its magic:  
+$$
+\frac{11!}{1! \cdot 4! \cdot 4! \cdot 2!}
+$$
+4. Step 4: Simplify Step-by-Step  
+Let’s break it down:  
+- (11! = 39,916,800)  
+- (4! = 24)  
+- (2! = 2)  
+#### Substituting these values:  
+$$
+\frac{39,916,800}{1 \cdot 24 \cdot 24 \cdot 2} = 34,650
+$$
+5. Step 5: The Grand Finale
+There are **34,650 unique arrangements** of 'MISSISSIPPI'. Erdős would marvel at the sheer elegance of these numbers—much like the way rivers meander through the land, permutations flow through possibilities.`,
+};
+
+const c = {
+  // c remains unchanged as it contains image generation prompts
+  "Render a Greek statue with warm marble tones and realistic proportions.":
+    "I don't have the ability to generate images right now. ",
+};
+
+const d = {
+  "Demonstrate all outputs.": `
+# Comprehensive Markdown Showcase
+## Headers
+~~~markdown
+# Large Header
+## Medium Header
+### Small Header
+~~~
+## Ordered Lists
+~~~markdown
+1. First Item
+2. Second Item
+   1. Subitem 1
+   2. Subitem 2
+3. Third Item
+~~~
+## Unordered Lists
+~~~markdown
+- First Item
+- Second Item
+  - Subitem 1
+  - Subitem 2
+~~~  
+## Links
+~~~markdown
+[Visit OpenAI](https://openai.com/)
+~~~
+## Images
+~~~markdown
+![Example Image](example.jpg)
+~~~
+![Example Image](example.jpg)
+## Inline Code
+~~~markdown
+\`console.log('Hello, Markdown!')\`
+~~~
+## Code Blocks
+\`\`\`markdown
+~~~javascript
+console.log(marked.parse('A Description List:\\n'
+                 + ':   Topic 1   :  Description 1\\n'
+                 + ': **Topic 2** : *Description 2*'));
+~~~
+\`\`\`
+## Tables
+~~~markdown
+| Name    | Value |
+|---------|-------|
+| Item A  | 10    |
+| Item B  | 20    |
+~~~
+## Blockquotes
+~~~markdown
+> Markdown makes writing beautiful.
+> - Markdown Fan
+~~~
+## Horizontal Rule
+~~~markdown
+---
+~~~
+## Font: Bold and Italic
+~~~markdown
+**Bold Text**  
+*Italic Text*
+~~~
+## Font: Strikethrough
+~~~markdown
+~~Struck-through text~~
+~~~
+---
+## Math: Inline 
+This is block level katex:
+~~~markdown
+$$
+c = \\\\pm\\\\sqrt{a^2 + b^2}
+$$
+~~~
+## Math: Block
+This is inline katex 
+~~~markdown
+$c = \\\\pm\\\\sqrt{a^2 + b^2}$
+~~~
+`,
+};
+
+export default { a, b, c, d };
--- a/packages/server/providers/tests/chat-stream-provider.test.ts
+++ b/packages/server/providers/tests/chat-stream-provider.test.ts
@@ -0,0 +1,70 @@
+import { describe, it, expect, vi } from 'vitest';
+import { BaseChatProvider, CommonProviderParams, ChatStreamProvider } from '../chat-stream-provider.ts';
+import { OpenAI } from 'openai';
+
+// Create a concrete implementation of BaseChatProvider for testing
+class TestChatProvider extends BaseChatProvider {
+  getOpenAIClient(param: CommonProviderParams): OpenAI {
+    return param.openai as OpenAI;
+  }
+
+  getStreamParams(param: CommonProviderParams, safeMessages: any[]): any {
+    return {
+      model: param.model,
+      messages: safeMessages,
+      stream: true,
+      max_tokens: param.maxTokens as number,
+    };
+  }
+
+  async processChunk(chunk: any, dataCallback: (data: any) => void): Promise<boolean> {
+    dataCallback({ type: 'chat', data: chunk });
+    return false;
+  }
+}
+
+// Mock dependencies
+vi.mock('../../lib/chat-sdk', () => ({
+  default: {
+    buildAssistantPrompt: vi.fn().mockReturnValue('Assistant prompt'),
+    buildMessageChain: vi.fn().mockReturnValue([
+      { role: 'system', content: 'System prompt' },
+      { role: 'user', content: 'User message' }
+    ])
+  }
+}));
+
+describe('ChatStreamProvider', () => {
+  it('should define the required interface', () => {
+    // Verify the interface has the required method
+    const mockProvider: ChatStreamProvider = {
+      handleStream: vi.fn()
+    };
+
+    expect(mockProvider.handleStream).toBeDefined();
+  });
+});
+
+describe('BaseChatProvider', () => {
+  it('should implement the ChatStreamProvider interface', () => {
+    // Create a concrete implementation
+    const provider = new TestChatProvider();
+
+    // Verify it implements the interface
+    expect(provider.handleStream).toBeInstanceOf(Function);
+    expect(provider.getOpenAIClient).toBeInstanceOf(Function);
+    expect(provider.getStreamParams).toBeInstanceOf(Function);
+    expect(provider.processChunk).toBeInstanceOf(Function);
+  });
+
+  it('should have abstract methods that need to be implemented', () => {
+    // This test verifies that the abstract methods exist
+    // We can't instantiate BaseChatProvider directly, so we use the concrete implementation
+    const provider = new TestChatProvider();
+
+    // Verify the abstract methods are implemented
+    expect(provider.getOpenAIClient).toBeDefined();
+    expect(provider.getStreamParams).toBeDefined();
+    expect(provider.processChunk).toBeDefined();
+  });
+});
--- a/packages/server/providers/cerebras.ts
+++ b/packages/server/providers/cerebras.ts
@@ -0,0 +1,71 @@
+import {OpenAI} from "openai";
+import {BaseChatProvider, CommonProviderParams} from "./chat-stream-provider.ts";
+
+export class CerebrasChatProvider extends BaseChatProvider {
+  getOpenAIClient(param: CommonProviderParams): OpenAI {
+    return new OpenAI({
+      baseURL: "https://api.cerebras.ai/v1",
+      apiKey: param.env.CEREBRAS_API_KEY,
+    });
+  }
+
+  getStreamParams(param: CommonProviderParams, safeMessages: any[]): any {
+      // models provided by cerebras do not follow standard tune params
+      // they must be individually configured
+    // const tuningParams = {
+    //   temperature: 0.86,
+    //   top_p: 0.98,
+    //   presence_penalty: 0.1,
+    //   frequency_penalty: 0.3,
+    //   max_tokens: param.maxTokens as number,
+    // };
+
+    return {
+      model: param.model,
+      messages: safeMessages,
+      stream: true
+        // ...tuningParams
+    };
+  }
+
+  async processChunk(chunk: any, dataCallback: (data: any) => void): Promise<boolean> {
+    if (chunk.choices && chunk.choices[0]?.finish_reason === "stop") {
+      dataCallback({ type: "chat", data: chunk });
+      return true;
+    }
+
+    dataCallback({ type: "chat", data: chunk });
+    return false;
+  }
+}
+
+export class CerebrasSdk {
+  private static provider = new CerebrasChatProvider();
+
+  static async handleCerebrasStream(
+    param: {
+      openai: OpenAI;
+      systemPrompt: any;
+      disableWebhookGeneration: boolean;
+      preprocessedContext: any;
+      maxTokens: unknown | number | undefined;
+      messages: any;
+      model: string;
+      env: Env;
+    },
+    dataCallback: (data) => void,
+  ) {
+    return this.provider.handleStream(
+      {
+        systemPrompt: param.systemPrompt,
+        preprocessedContext: param.preprocessedContext,
+        maxTokens: param.maxTokens,
+        messages: param.messages,
+        model: param.model,
+        env: param.env,
+        disableWebhookGeneration: param.disableWebhookGeneration,
+      },
+      dataCallback,
+    );
+  }
+}
--- a/packages/server/providers/chat-stream-provider.ts
+++ b/packages/server/providers/chat-stream-provider.ts
@@ -0,0 +1,49 @@
+import { OpenAI } from "openai";
+import ChatSdk from "../lib/chat-sdk.ts";
+
+export interface CommonProviderParams {
+  openai?: OpenAI; // Optional for providers that use a custom client.
+  systemPrompt: any;
+  preprocessedContext: any;
+  maxTokens: number | unknown | undefined;
+  messages: any;
+  model: string;
+  env: Env;
+  disableWebhookGeneration?: boolean;
+  // Additional fields can be added as needed
+}
+
+export interface ChatStreamProvider {
+  handleStream(
+    param: CommonProviderParams,
+    dataCallback: (data: any) => void,
+  ): Promise<any>;
+}
+
+export abstract class BaseChatProvider implements ChatStreamProvider {
+  abstract getOpenAIClient(param: CommonProviderParams): OpenAI;
+  abstract getStreamParams(param: CommonProviderParams, safeMessages: any[]): any;
+  abstract async processChunk(chunk: any, dataCallback: (data: any) => void): Promise<boolean>;
+
+  async handleStream(
+    param: CommonProviderParams,
+    dataCallback: (data: any) => void,
+  ) {
+    const assistantPrompt = ChatSdk.buildAssistantPrompt({ maxTokens: param.maxTokens });
+    const safeMessages = ChatSdk.buildMessageChain(param.messages, {
+      systemPrompt: param.systemPrompt,
+      model: param.model,
+      assistantPrompt,
+      toolResults: param.preprocessedContext,
+    });
+
+    const client = this.getOpenAIClient(param);
+    const streamParams = this.getStreamParams(param, safeMessages);
+    const stream = await client.chat.completions.create(streamParams);
+
+    for await (const chunk of stream) {
+      const shouldBreak = await this.processChunk(chunk, dataCallback);
+      if (shouldBreak) break;
+    }
+  }
+}
--- a/packages/server/providers/claude.ts
+++ b/packages/server/providers/claude.ts
@@ -0,0 +1,124 @@
+import Anthropic from "@anthropic-ai/sdk";
+import {OpenAI} from "openai";
+import {
+  _NotCustomized,
+  ISimpleType,
+  ModelPropertiesDeclarationToProperties,
+  ModelSnapshotType2,
+  UnionStringArray,
+} from "mobx-state-tree";
+import ChatSdk from "../lib/chat-sdk.ts";
+import {BaseChatProvider, CommonProviderParams} from "./chat-stream-provider.ts";
+
+export class ClaudeChatProvider extends BaseChatProvider {
+  private anthropic: Anthropic | null = null;
+
+  getOpenAIClient(param: CommonProviderParams): OpenAI {
+    // Claude doesn't use OpenAI client directly, but we need to return something
+    // to satisfy the interface. The actual Anthropic client is created in getStreamParams.
+    return param.openai as OpenAI;
+  }
+
+  getStreamParams(param: CommonProviderParams, safeMessages: any[]): any {
+    this.anthropic = new Anthropic({
+      apiKey: param.env.ANTHROPIC_API_KEY,
+    });
+
+    const claudeTuningParams = {
+      temperature: 0.7,
+      max_tokens: param.maxTokens as number,
+    };
+
+    return {
+      stream: true,
+      model: param.model,
+      messages: safeMessages,
+      ...claudeTuningParams
+    };
+  }
+
+  async processChunk(chunk: any, dataCallback: (data: any) => void): Promise<boolean> {
+    if (chunk.type === "message_stop") {
+      dataCallback({
+        type: "chat",
+        data: {
+          choices: [
+            {
+              delta: { content: "" },
+              logprobs: null,
+              finish_reason: "stop",
+            },
+          ],
+        },
+      });
+      return true;
+    }
+
+    dataCallback({ type: "chat", data: chunk });
+    return false;
+  }
+
+  // Override the base handleStream method to use Anthropic client instead of OpenAI
+  async handleStream(
+    param: CommonProviderParams,
+    dataCallback: (data: any) => void,
+  ) {
+    const assistantPrompt = ChatSdk.buildAssistantPrompt({ maxTokens: param.maxTokens });
+    const safeMessages = ChatSdk.buildMessageChain(param.messages, {
+      systemPrompt: param.systemPrompt,
+      model: param.model,
+      assistantPrompt,
+      toolResults: param.preprocessedContext,
+    });
+
+    const streamParams = this.getStreamParams(param, safeMessages);
+
+    if (!this.anthropic) {
+      throw new Error("Anthropic client not initialized");
+    }
+
+    const stream = await this.anthropic.messages.create(streamParams);
+
+    for await (const chunk of stream) {
+      const shouldBreak = await this.processChunk(chunk, dataCallback);
+      if (shouldBreak) break;
+    }
+  }
+}
+
+// Legacy class for backward compatibility
+export class ClaudeChatSdk {
+  private static provider = new ClaudeChatProvider();
+
+  static async handleClaudeStream(
+    param: {
+      openai: OpenAI;
+      systemPrompt: any;
+      preprocessedContext: ModelSnapshotType2<
+        ModelPropertiesDeclarationToProperties<{
+          role: ISimpleType<UnionStringArray<string[]>>;
+          content: ISimpleType<unknown>;
+        }>,
+        _NotCustomized
+      >;
+      maxTokens: unknown | number | undefined;
+      messages: any;
+      model: string;
+      env: Env;
+    },
+    dataCallback: (data) => void,
+  ) {
+    return this.provider.handleStream(
+      {
+        openai: param.openai,
+        systemPrompt: param.systemPrompt,
+        preprocessedContext: param.preprocessedContext,
+        maxTokens: param.maxTokens,
+        messages: param.messages,
+        model: param.model,
+        env: param.env,
+      },
+      dataCallback,
+    );
+  }
+}
--- a/packages/server/providers/cloudflareAi.ts
+++ b/packages/server/providers/cloudflareAi.ts
@@ -0,0 +1,141 @@
+import {OpenAI} from "openai";
+import {BaseChatProvider, CommonProviderParams} from "./chat-stream-provider.ts";
+
+export class CloudflareAiChatProvider extends BaseChatProvider {
+  getOpenAIClient(param: CommonProviderParams): OpenAI {
+    const cfAiURL = `https://api.cloudflare.com/client/v4/accounts/${param.env.CLOUDFLARE_ACCOUNT_ID}/ai/v1`;
+
+    return new OpenAI({
+      apiKey: param.env.CLOUDFLARE_API_KEY,
+      baseURL: cfAiURL,
+    });
+  }
+
+  getStreamParams(param: CommonProviderParams, safeMessages: any[]): any {
+    const generationParams: Record<string, any> = {
+      model: this.getModelWithPrefix(param.model),
+      messages: safeMessages,
+      stream: true,
+    };
+
+    // Set max_tokens based on model
+    if (this.getModelPrefix(param.model) === "@cf/meta") {
+      generationParams["max_tokens"] = 4096;
+    }
+
+    if (this.getModelPrefix(param.model) === "@hf/mistral") {
+      generationParams["max_tokens"] = 4096;
+    }
+
+    if (param.model.toLowerCase().includes("hermes-2-pro-mistral-7b")) {
+      generationParams["max_tokens"] = 1000;
+    }
+
+    if (param.model.toLowerCase().includes("openhermes-2.5-mistral-7b-awq")) {
+      generationParams["max_tokens"] = 1000;
+    }
+
+    if (param.model.toLowerCase().includes("deepseek-coder-6.7b-instruct-awq")) {
+      generationParams["max_tokens"] = 590;
+    }
+
+    if (param.model.toLowerCase().includes("deepseek-math-7b-instruct")) {
+      generationParams["max_tokens"] = 512;
+    }
+
+    if (param.model.toLowerCase().includes("neural-chat-7b-v3-1-awq")) {
+      generationParams["max_tokens"] = 590;
+    }
+
+    if (param.model.toLowerCase().includes("openchat-3.5-0106")) {
+      generationParams["max_tokens"] = 2000;
+    }
+
+    return generationParams;
+  }
+
+  private getModelPrefix(model: string): string {
+    let modelPrefix = `@cf/meta`;
+
+    if (model.toLowerCase().includes("llama")) {
+      modelPrefix = `@cf/meta`;
+    }
+
+    if (model.toLowerCase().includes("hermes-2-pro-mistral-7b")) {
+      modelPrefix = `@hf/nousresearch`;
+    }
+
+    if (model.toLowerCase().includes("mistral-7b-instruct")) {
+      modelPrefix = `@hf/mistral`;
+    }
+
+    if (model.toLowerCase().includes("gemma")) {
+      modelPrefix = `@cf/google`;
+    }
+
+    if (model.toLowerCase().includes("deepseek")) {
+      modelPrefix = `@cf/deepseek-ai`;
+    }
+
+    if (model.toLowerCase().includes("openchat-3.5-0106")) {
+      modelPrefix = `@cf/openchat`;
+    }
+
+    const isNueralChat = model
+      .toLowerCase()
+      .includes("neural-chat-7b-v3-1-awq");
+    if (
+      isNueralChat ||
+      model.toLowerCase().includes("openhermes-2.5-mistral-7b-awq") ||
+      model.toLowerCase().includes("zephyr-7b-beta-awq") ||
+      model.toLowerCase().includes("deepseek-coder-6.7b-instruct-awq")
+    ) {
+      modelPrefix = `@hf/thebloke`;
+    }
+
+    return modelPrefix;
+  }
+
+  private getModelWithPrefix(model: string): string {
+    return `${this.getModelPrefix(model)}/${model}`;
+  }
+
+  async processChunk(chunk: any, dataCallback: (data: any) => void): Promise<boolean> {
+    if (chunk.choices && chunk.choices[0]?.finish_reason === "stop") {
+      dataCallback({ type: "chat", data: chunk });
+      return true;
+    }
+
+    dataCallback({ type: "chat", data: chunk });
+    return false;
+  }
+}
+
+export class CloudflareAISdk {
+  private static provider = new CloudflareAiChatProvider();
+
+  static async handleCloudflareAIStream(
+    param: {
+      openai: OpenAI;
+      systemPrompt: any;
+      preprocessedContext: any;
+      maxTokens: unknown | number | undefined;
+      messages: any;
+      model: string;
+      env: Env;
+    },
+    dataCallback: (data) => void,
+  ) {
+    return this.provider.handleStream(
+      {
+        systemPrompt: param.systemPrompt,
+        preprocessedContext: param.preprocessedContext,
+        maxTokens: param.maxTokens,
+        messages: param.messages,
+        model: param.model,
+        env: param.env,
+      },
+      dataCallback,
+    );
+  }
+}
--- a/packages/server/providers/fireworks.ts
+++ b/packages/server/providers/fireworks.ts
@@ -0,0 +1,74 @@
+import { OpenAI } from "openai";
+import {
+  _NotCustomized,
+  castToSnapshot,
+  getSnapshot,
+  ISimpleType,
+  ModelPropertiesDeclarationToProperties,
+  ModelSnapshotType2,
+  UnionStringArray,
+} from "mobx-state-tree";
+import Message from "../models/Message.ts";
+import ChatSdk from "../lib/chat-sdk.ts";
+import { BaseChatProvider, CommonProviderParams } from "./chat-stream-provider.ts";
+
+export class FireworksAiChatProvider extends BaseChatProvider {
+  getOpenAIClient(param: CommonProviderParams): OpenAI {
+    return new OpenAI({
+      apiKey: param.env.FIREWORKS_API_KEY,
+      baseURL: "https://api.fireworks.ai/inference/v1",
+    });
+  }
+
+  getStreamParams(param: CommonProviderParams, safeMessages: any[]): any {
+    let modelPrefix = "accounts/fireworks/models/";
+    if (param.model.toLowerCase().includes("yi-")) {
+      modelPrefix = "accounts/yi-01-ai/models/";
+    }
+
+    return {
+      model: `${modelPrefix}${param.model}`,
+      messages: safeMessages,
+      stream: true,
+    };
+  }
+
+  async processChunk(chunk: any, dataCallback: (data: any) => void): Promise<boolean> {
+    if (chunk.choices && chunk.choices[0]?.finish_reason === "stop") {
+      dataCallback({ type: "chat", data: chunk });
+      return true;
+    }
+
+    dataCallback({ type: "chat", data: chunk });
+    return false;
+  }
+}
+
+export class FireworksAiChatSdk {
+  private static provider = new FireworksAiChatProvider();
+
+  static async handleFireworksStream(
+    param: {
+      openai: OpenAI;
+      systemPrompt: any;
+      preprocessedContext: any;
+      maxTokens: number;
+      messages: any;
+      model: any;
+      env: Env;
+    },
+    dataCallback: (data) => void,
+  ) {
+    return this.provider.handleStream(
+      {
+        systemPrompt: param.systemPrompt,
+        preprocessedContext: param.preprocessedContext,
+        maxTokens: param.maxTokens,
+        messages: param.messages,
+        model: param.model,
+        env: param.env,
+      },
+      dataCallback,
+    );
+  }
+}
--- a/packages/server/providers/google.ts
+++ b/packages/server/providers/google.ts
@@ -0,0 +1,74 @@
+import { OpenAI } from "openai";
+import ChatSdk from "../lib/chat-sdk.ts";
+import { StreamParams } from "../services/ChatService.ts";
+import { BaseChatProvider, CommonProviderParams } from "./chat-stream-provider.ts";
+
+export class GoogleChatProvider extends BaseChatProvider {
+  getOpenAIClient(param: CommonProviderParams): OpenAI {
+    return new OpenAI({
+      baseURL: "https://generativelanguage.googleapis.com/v1beta/openai",
+      apiKey: param.env.GEMINI_API_KEY,
+    });
+  }
+
+  getStreamParams(param: CommonProviderParams, safeMessages: any[]): any {
+    return {
+      model: param.model,
+      messages: safeMessages,
+      stream: true,
+    };
+  }
+
+  async processChunk(chunk: any, dataCallback: (data: any) => void): Promise<boolean> {
+    if (chunk.choices?.[0]?.finish_reason === "stop") {
+      dataCallback({
+        type: "chat",
+        data: {
+          choices: [
+            {
+              delta: { content: chunk.choices[0].delta.content || "" },
+              finish_reason: "stop",
+              index: chunk.choices[0].index,
+            },
+          ],
+        },
+      });
+      return true;
+    } else {
+      dataCallback({
+        type: "chat",
+        data: {
+          choices: [
+            {
+              delta: { content: chunk.choices?.[0]?.delta?.content || "" },
+              finish_reason: null,
+              index: chunk.choices?.[0]?.index || 0,
+            },
+          ],
+        },
+      });
+      return false;
+    }
+  }
+}
+
+export class GoogleChatSdk {
+  private static provider = new GoogleChatProvider();
+
+  static async handleGoogleStream(
+    param: StreamParams,
+    dataCallback: (data) => void,
+  ) {
+    return this.provider.handleStream(
+      {
+        systemPrompt: param.systemPrompt,
+        preprocessedContext: param.preprocessedContext,
+        maxTokens: param.maxTokens,
+        messages: param.messages,
+        model: param.model,
+        env: param.env,
+      },
+      dataCallback,
+    );
+  }
+}
--- a/packages/server/providers/groq.ts
+++ b/packages/server/providers/groq.ts
@@ -0,0 +1,80 @@
+import { OpenAI } from "openai";
+import {
+  _NotCustomized,
+  ISimpleType,
+  ModelPropertiesDeclarationToProperties,
+  ModelSnapshotType2,
+  UnionStringArray,
+} from "mobx-state-tree";
+import { BaseChatProvider, CommonProviderParams } from "./chat-stream-provider.ts";
+
+export class GroqChatProvider extends BaseChatProvider {
+  getOpenAIClient(param: CommonProviderParams): OpenAI {
+    return new OpenAI({
+      baseURL: "https://api.groq.com/openai/v1",
+      apiKey: param.env.GROQ_API_KEY,
+    });
+  }
+
+  getStreamParams(param: CommonProviderParams, safeMessages: any[]): any {
+    const tuningParams = {
+      temperature: 0.86,
+      top_p: 0.98,
+      presence_penalty: 0.1,
+      frequency_penalty: 0.3,
+      max_tokens: param.maxTokens as number,
+    };
+
+    return {
+      model: param.model,
+      messages: safeMessages,
+      stream: true,
+      ...tuningParams
+    };
+  }
+
+  async processChunk(chunk: any, dataCallback: (data: any) => void): Promise<boolean> {
+    if (chunk.choices && chunk.choices[0]?.finish_reason === "stop") {
+      dataCallback({ type: "chat", data: chunk });
+      return true;
+    }
+
+    dataCallback({ type: "chat", data: chunk });
+    return false;
+  }
+}
+
+export class GroqChatSdk {
+  private static provider = new GroqChatProvider();
+
+  static async handleGroqStream(
+    param: {
+      openai: OpenAI;
+      systemPrompt: any;
+      preprocessedContext: ModelSnapshotType2<
+        ModelPropertiesDeclarationToProperties<{
+          role: ISimpleType<UnionStringArray<string[]>>;
+          content: ISimpleType<unknown>;
+        }>,
+        _NotCustomized
+      >;
+      maxTokens: unknown | number | undefined;
+      messages: any;
+      model: string;
+      env: Env;
+    },
+    dataCallback: (data) => void,
+  ) {
+    return this.provider.handleStream(
+      {
+        systemPrompt: param.systemPrompt,
+        preprocessedContext: param.preprocessedContext,
+        maxTokens: param.maxTokens,
+        messages: param.messages,
+        model: param.model,
+        env: param.env,
+      },
+      dataCallback,
+    );
+  }
+}
--- a/packages/server/providers/openai.ts
+++ b/packages/server/providers/openai.ts
@@ -0,0 +1,114 @@
+import { OpenAI } from "openai";
+import { Utils } from "../lib/utils.ts";
+import { ChatCompletionCreateParamsStreaming } from "openai/resources/chat/completions/completions";
+import { BaseChatProvider, CommonProviderParams } from "./chat-stream-provider.ts";
+
+export class OpenAiChatProvider extends BaseChatProvider {
+  getOpenAIClient(param: CommonProviderParams): OpenAI {
+    return param.openai as OpenAI;
+  }
+
+  getStreamParams(param: CommonProviderParams, safeMessages: any[]): ChatCompletionCreateParamsStreaming {
+    const isO1 = () => {
+      if (param.model === "o1-preview" || param.model === "o1-mini") {
+        return true;
+      }
+    };
+
+    const tuningParams: Record<string, any> = {};
+
+    const gpt4oTuningParams = {
+      temperature: 0.86,
+      top_p: 0.98,
+      presence_penalty: 0.1,
+      frequency_penalty: 0.3,
+      max_tokens: param.maxTokens as number,
+    };
+
+    const getTuningParams = () => {
+      if (isO1()) {
+        tuningParams["temperature"] = 1;
+        tuningParams["max_completion_tokens"] = (param.maxTokens as number) + 10000;
+        return tuningParams;
+      }
+      return gpt4oTuningParams;
+    };
+
+    let completionRequest: ChatCompletionCreateParamsStreaming = {
+      model: param.model,
+      stream: true,
+      messages: safeMessages
+    };
+
+    const client = this.getOpenAIClient(param);
+    const isLocal = client.baseURL.includes("localhost");
+
+    if(isLocal) {
+      completionRequest["messages"] = Utils.normalizeWithBlanks(safeMessages);
+      completionRequest["stream_options"] = {
+        include_usage: true
+      };
+    } else {
+      completionRequest = {...completionRequest, ...getTuningParams()};
+    }
+
+    return completionRequest;
+  }
+
+  async processChunk(chunk: any, dataCallback: (data: any) => void): Promise<boolean> {
+    const isLocal = chunk.usage !== undefined;
+
+    if (isLocal && chunk.usage) {
+      dataCallback({
+        type: "chat",
+        data: {
+          choices: [
+            {
+              delta: { content: "" },
+              logprobs: null,
+              finish_reason: "stop",
+            },
+          ],
+        },
+      });
+      return true; // Break the stream
+    }
+
+    dataCallback({ type: "chat", data: chunk });
+    return false; // Continue the stream
+  }
+}
+
+// Legacy class for backward compatibility
+export class OpenAiChatSdk {
+  private static provider = new OpenAiChatProvider();
+
+  static async handleOpenAiStream(
+    ctx: {
+      openai: OpenAI;
+      systemPrompt: any;
+      preprocessedContext: any;
+      maxTokens: unknown | number | undefined;
+      messages: any;
+      model: any;
+    },
+    dataCallback: (data: any) => any,
+  ) {
+    if (!ctx.messages?.length) {
+      return new Response("No messages provided", { status: 400 });
+    }
+
+    return this.provider.handleStream(
+      {
+        openai: ctx.openai,
+        systemPrompt: ctx.systemPrompt,
+        preprocessedContext: ctx.preprocessedContext,
+        maxTokens: ctx.maxTokens,
+        messages: ctx.messages,
+        model: ctx.model,
+        env: {} as Env, // This is not used in OpenAI provider
+      },
+      dataCallback,
+    );
+  }
+}
--- a/packages/server/providers/xai.ts
+++ b/packages/server/providers/xai.ts
@@ -0,0 +1,73 @@
+import { OpenAI } from "openai";
+import { BaseChatProvider, CommonProviderParams } from "./chat-stream-provider.ts";
+
+export class XaiChatProvider extends BaseChatProvider {
+    getOpenAIClient(param: CommonProviderParams): OpenAI {
+        return new OpenAI({
+            baseURL: "https://api.x.ai/v1",
+            apiKey: param.env.XAI_API_KEY,
+        });
+    }
+
+    getStreamParams(param: CommonProviderParams, safeMessages: any[]): any {
+        const tuningParams = {
+            temperature: 0.75,
+        };
+
+        const getTuningParams = () => {
+            return tuningParams;
+        };
+
+        return {
+            model: param.model,
+            messages: safeMessages,
+            stream: true,
+            ...getTuningParams(),
+        };
+    }
+
+    async processChunk(chunk: any, dataCallback: (data: any) => void): Promise<boolean> {
+        if (chunk.choices && chunk.choices[0]?.finish_reason === "stop") {
+            dataCallback({ type: "chat", data: chunk });
+            return true;
+        }
+
+        dataCallback({ type: "chat", data: chunk });
+        return false;
+    }
+}
+
+export class XaiChatSdk {
+    private static provider = new XaiChatProvider();
+
+    static async handleXaiStream(
+        ctx: {
+            openai: OpenAI;
+            systemPrompt: any;
+            preprocessedContext: any;
+            maxTokens: unknown | number | undefined;
+            messages: any;
+            disableWebhookGeneration: boolean;
+            model: any;
+            env: Env;
+        },
+        dataCallback: (data: any) => any,
+    ) {
+        if (!ctx.messages?.length) {
+            return new Response("No messages provided", { status: 400 });
+        }
+
+        return this.provider.handleStream(
+            {
+                systemPrompt: ctx.systemPrompt,
+                preprocessedContext: ctx.preprocessedContext,
+                maxTokens: ctx.maxTokens,
+                messages: ctx.messages,
+                model: ctx.model,
+                env: ctx.env,
+                disableWebhookGeneration: ctx.disableWebhookGeneration,
+            },
+            dataCallback,
+        );
+    }
+}
--- a/packages/server/server.ts
+++ b/packages/server/server.ts
@@ -0,0 +1,93 @@
+// import Server from "./packages/server/index.ts";
+import {BunSqliteKVNamespace} from "./storage/BunSqliteKVNamespace";
+import {readdir} from 'node:fs/promises';
+import type { RequestLike } from "itty-router";
+
+import {config} from "dotenv";
+import Server from ".";
+import DurableObjectLocal from "./ServerCoordinatorBun";
+
+const router = Server.Router();
+
+config({ path: ['../../.dev.vars'] })
+
+export default {
+    port: 3003,
+    fetch: async (request: RequestLike, env: { [key: string]: any; }, ctx: any) =>{
+        console.log("[trace] request: ", request.method, request.url, "headers: ", request.headers.get("referer"), "body: ", request.body, "env: ", env, "ctx: ", ctx, "")
+
+        env["SERVER_COORDINATOR"] = DurableObjectLocal
+        env["ASSETS"] = assetHandler.ASSETS
+        env["EVENTSOURCE_HOST"] = process.env.EVENTSOURCE_HOST
+        env["GROQ_API_KEY"] = process.env.GROQ_API_KEY
+        env["ANTHROPIC_API_KEY"] = process.env.ANTHROPIC_API_KEY
+        env["FIREWORKS_API_KEY"] = process.env.FIREWORKS_API_KEY
+        env["XAI_API_KEY"] = process.env.XAI_API_KEY
+        env["CEREBRAS_API_KEY"] = process.env.CEREBRAS_API_KEY
+        env["CLOUDFLARE_API_KEY"] = process.env.CLOUDFLARE_API_KEY
+        env["CLOUDFLARE_ACCOUNT_ID"] = process.env.CLOUDFLARE_ACCOUNT_ID
+        env["KV_STORAGE"] = new BunSqliteKVNamespace("open-gsio")
+
+
+        try {
+            const controller = new AbortController();
+            const timeout = new Promise((_, reject) =>
+                setTimeout(() => {
+                    controller.abort();
+                    reject(new Error('Request timeout after 5s'));
+                }, 5000)
+            );
+
+            return await Promise.race([
+                router.fetch(request, env, ctx),
+                timeout
+            ]);
+        } catch (e) {
+            console.error("Error handling request:", e);
+            return new Response("Server Error", { status: 500 });
+        }
+        
+    }
+}
+
+const assetHandler = {
+    ASSETS: {
+        /**
+         * Fetches the requested static asset from local dist
+         *
+         * @param {Request} request - The incoming Fetch API Request object.
+         * @returns {Promise<Response>} A Promise that resolves with the Response for the requested asset,
+         *                              or a 404 Response if the asset is not found or an error occurs.
+         */
+        async fetch(request: Request): Promise<Response> {
+            // Serialize incoming request URL
+            const originalUrl = new URL(request.url);
+            const url = new URL(request.url);
+
+            // List all files in the public directory
+            const PUBLIC_DIR = '../client/public/';
+            const publicFiles = await readdir(PUBLIC_DIR, {recursive: true});
+
+            // Get the filename from pathname and remove any path traversal attempts
+            const filename = url.pathname.split('/').pop()?.replace(/\.\./g, '') || '';
+
+            const isStatic = publicFiles.some(file => file === filename);
+
+            if (url.pathname === "/") {
+                url.pathname = "/index.html";
+            } else if (isStatic) {
+                url.pathname = `/static${url.pathname}`;
+            }
+
+            const dist = "../client/dist/client"
+
+            try {
+                return new Response(Bun.file(`${dist}${url.pathname}`));
+            } catch (error) {
+                // Log the error with the original requested path
+                console.error(`Error reading asset from path ${originalUrl.pathname}:`, error);
+                return new Response('Asset not found on disk', { status: 404 });
+            }
+        }
+    }
+}
--- a/packages/server/services/AssetService.ts
+++ b/packages/server/services/AssetService.ts
@@ -0,0 +1,50 @@
+import { types } from "mobx-state-tree";
+import { renderPage } from "vike/server";
+
+export default types
+  .model("StaticAssetStore", {})
+  .volatile((self) => ({
+    env: {} as Env,
+    ctx: {} as ExecutionContext,
+  }))
+  .actions((self) => ({
+    setEnv(env: Env) {
+      self.env = env;
+    },
+    setCtx(ctx: ExecutionContext) {
+      self.ctx = ctx;
+    },
+    async handleSsr(
+      url: string,
+      headers: Headers,
+      env: Vike.PageContext["env"],
+    ) {
+      console.log("handleSsr");
+      const pageContextInit = {
+        urlOriginal: url,
+        headersOriginal: headers,
+        fetch: (...args: Parameters<typeof fetch>) => fetch(...args),
+        env,
+      };
+
+      const pageContext = await renderPage(pageContextInit);
+      const { httpResponse } = pageContext;
+
+
+      if (!httpResponse) {
+        return null;
+      } else {
+        const { statusCode: status, headers } = httpResponse;
+        return new Response(httpResponse.pipe, { headers, status });
+      }
+    },
+    async handleStaticAssets(request: Request, env) {
+      console.log("handleStaticAssets");
+      try {
+        return await env.ASSETS.fetch(request);
+      } catch (error) {
+        console.error("Error serving static asset:", error);
+        return new Response("Asset not found", { status: 404 });
+      }
+    },
+  }));
--- a/packages/server/services/ChatService.ts
+++ b/packages/server/services/ChatService.ts
@@ -0,0 +1,367 @@
+import {flow, getSnapshot, types} from 'mobx-state-tree';
+import OpenAI from 'openai';
+import ChatSdk from '../lib/chat-sdk.ts';
+import Message from "../models/Message.ts";
+import O1Message from "../models/O1Message.ts";
+import {getModelFamily, ModelFamily, SUPPORTED_MODELS} from "@open-gsio/ai/supported-models";
+import {OpenAiChatSdk} from "../providers/openai.ts";
+import {GroqChatSdk} from "../providers/groq.ts";
+import {ClaudeChatSdk} from "../providers/claude.ts";
+import {FireworksAiChatSdk} from "../providers/fireworks.ts";
+import handleStreamData from "../lib/handleStreamData.ts";
+import {GoogleChatSdk} from "../providers/google.ts";
+import {XaiChatSdk} from "../providers/xai.ts";
+import {CerebrasSdk} from "../providers/cerebras.ts";
+import {CloudflareAISdk} from "../providers/cloudflareAi.ts";
+
+export interface StreamParams {
+    env: Env;
+    openai: OpenAI;
+    messages: any[];
+    model: string;
+    systemPrompt: string;
+    preprocessedContext: any;
+    maxTokens: number;
+}
+
+const activeStreamType = types.model({
+    name: types.optional(types.string, ""),
+    maxTokens: types.optional(types.number, 0),
+    systemPrompt: types.optional(types.string, ""),
+    model: types.optional(types.string, ""),
+    messages: types.optional(types.array(types.frozen()), []),
+});
+
+const activeStreamsMap = types.map(
+    activeStreamType,
+);
+
+const ChatService = types
+    .model('ChatService', {
+        openAIApiKey: types.optional(types.string, ""),
+        openAIBaseURL: types.optional(types.string, ""),
+        activeStreams: types.optional(
+            activeStreamsMap,
+            {}
+        ),
+        maxTokens: types.number,
+        systemPrompt: types.string
+    })
+    .volatile(self => ({
+        openai: {} as OpenAI,
+        env: {} as Env,
+    }))
+    .actions(self => {
+        // Helper functions
+        const createMessageInstance = (message: any) => {
+            if (typeof message.content === 'string') {
+                return Message.create({
+                    role: message.role,
+                    content: message.content,
+                });
+            }
+            if (Array.isArray(message.content)) {
+                const m = O1Message.create({
+                    role: message.role,
+                    content: message.content.map(item => ({
+                        type: item.type,
+                        text: item.text
+                    })),
+                });
+                return m;
+            }
+            throw new Error('Unsupported message format');
+        };
+
+
+        const createStreamParams = async (
+            streamConfig: any,
+            dynamicContext: any,
+            durableObject: any
+        ): Promise<StreamParams> => {
+
+            return {
+                env: self.env,
+                openai: self.openai,
+                messages: streamConfig.messages.map(createMessageInstance),
+                model: streamConfig.model,
+                systemPrompt: streamConfig.systemPrompt,
+                preprocessedContext: getSnapshot(dynamicContext),
+                maxTokens: await durableObject.dynamicMaxTokens(
+                    streamConfig.messages,
+                    2000
+                ),
+            }
+        };
+
+        const modelHandlers = {
+            openai: (params: StreamParams, dataHandler: Function) =>
+                OpenAiChatSdk.handleOpenAiStream(params, dataHandler),
+            groq: (params: StreamParams, dataHandler: Function) =>
+                GroqChatSdk.handleGroqStream(params, dataHandler),
+            claude: (params: StreamParams, dataHandler: Function) =>
+                ClaudeChatSdk.handleClaudeStream(params, dataHandler),
+            fireworks: (params: StreamParams, dataHandler: Function) =>
+                FireworksAiChatSdk.handleFireworksStream(params, dataHandler),
+            google: (params: StreamParams, dataHandler: Function) =>
+                GoogleChatSdk.handleGoogleStream(params, dataHandler),
+            xai: (params: StreamParams, dataHandler: Function) =>
+                XaiChatSdk.handleXaiStream(params, dataHandler),
+            cerebras: (params: StreamParams, dataHandler: Function) =>
+                CerebrasSdk.handleCerebrasStream(params, dataHandler),
+            cloudflareAI: (params: StreamParams, dataHandler: Function) =>
+                CloudflareAISdk.handleCloudflareAIStream(params, dataHandler)
+        };
+
+        return {
+            async getSupportedModels() {
+                const isLocal = self.env.OPENAI_API_ENDPOINT && self.env.OPENAI_API_ENDPOINT.includes("localhost");
+                console.log({isLocal})
+                if(isLocal) {
+                    console.log("getting local models")
+                    const openaiClient = new OpenAI({baseURL: self.env.OPENAI_API_ENDPOINT})
+                    const models = await openaiClient.models.list();
+                    return Response.json(
+                        models.data
+                            .filter(model => model.id.includes("mlx"))
+                            .map(model => model.id));
+                }
+                return Response.json(SUPPORTED_MODELS);
+            },
+            setActiveStream(streamId: string, stream: any) {
+                const validStream = {
+                    name: stream?.name || "Unnamed Stream",
+                    maxTokens: stream?.maxTokens || 0,
+                    systemPrompt: stream?.systemPrompt || "",
+                    model: stream?.model || "",
+                    messages: stream?.messages || [],
+                };
+
+                self.activeStreams.set(streamId, validStream);
+            },
+
+            removeActiveStream(streamId: string) {
+                self.activeStreams.delete(streamId);
+            },
+            setEnv(env: Env) {
+                self.env = env;
+
+                if(env.OPENAI_API_ENDPOINT && env.OPENAI_API_ENDPOINT.includes("localhost")) {
+                    self.openai = new OpenAI({
+                        apiKey: self.env.OPENAI_API_KEY,
+                        baseURL: self.env.OPENAI_API_ENDPOINT,
+                    });
+                } else{
+                    self.openai = new OpenAI({
+                        apiKey: self.openAIApiKey,
+                        baseURL: self.openAIBaseURL,
+                    });
+                }
+            },
+
+            handleChatRequest: async (request: Request) => {
+                return ChatSdk.handleChatRequest(request, {
+                    openai: self.openai,
+                    env: self.env,
+                    systemPrompt: self.systemPrompt,
+                    maxTokens: self.maxTokens
+                });
+            },
+
+
+            async runModelHandler(params: {
+                streamConfig: any;
+                streamParams: any;
+                controller: ReadableStreamDefaultController;
+                encoder: TextEncoder;
+                streamId: string;
+            }) {
+                const {streamConfig, streamParams, controller, encoder, streamId} = params;
+
+                const useModelFamily = () => {
+                    return !self.env.OPENAI_API_ENDPOINT || !self.env.OPENAI_API_ENDPOINT.includes("localhost") ? getModelFamily(streamConfig.model) : "openai";
+                }
+
+                const modelFamily = useModelFamily();
+
+                const useModelHandler = () => {
+                    return !self.env.OPENAI_API_ENDPOINT || !self.env.OPENAI_API_ENDPOINT.includes("localhost") ? modelHandlers[modelFamily as ModelFamily] : modelHandlers.openai;
+                }
+
+                const handler = useModelHandler();
+                
+
+                if (handler) {
+                    console.log(`Using provider: ${modelFamily}`);
+                    try {
+                        await handler(streamParams, handleStreamData(controller, encoder));
+
+                    } catch (error) {
+                        const message = error.message.toLowerCase();
+
+                        if (message.includes("413 ") || (message.includes("maximum") || message.includes("too long") || message.includes("too large"))) {
+                            throw new ClientError(`Error! Content length exceeds limits. Try shortening your message or editing an earlier message.`, 413, {
+                                model: streamConfig.model,
+                                maxTokens: streamParams.maxTokens
+                            })
+                        }
+                        if (message.includes("429 ")) {
+                            throw new ClientError(`Error! Rate limit exceeded. Wait a few minutes before trying again.`, 429, {
+                                model: streamConfig.model,
+                                maxTokens: streamParams.maxTokens
+                            })
+                        }
+                        if (message.includes("404")) {
+                            throw new ClientError(`Something went wrong, try again.`, 413, {})
+                        }
+                        throw error;
+                    }
+                }
+            },
+
+            createSseReadableStream(params: {
+                streamId: string;
+                streamConfig: any;
+                savedStreamConfig: string;
+                durableObject: any;
+            }) {
+                const {streamId, streamConfig, savedStreamConfig, durableObject} = params;
+
+                return new ReadableStream({
+                    async start(controller) {
+                        const encoder = new TextEncoder();
+
+                        try {
+                            const dynamicContext = Message.create(streamConfig.preprocessedContext);
+
+                            // Process the stream data using the appropriate handler
+                            const streamParams = await createStreamParams(
+                                streamConfig,
+                                dynamicContext,
+                                durableObject
+                            );
+
+                            try {
+                                await self.runModelHandler({
+                                    streamConfig,
+                                    streamParams,
+                                    controller,
+                                    encoder,
+                                    streamId,
+                                });
+                            } catch (e) {
+                                console.log("error caught at runModelHandler")
+                                throw e;
+                            }
+
+                        } catch (error) {
+                            console.error(`chatService::handleSseStream::${streamId}::Error`, error);
+
+                            if (error instanceof ClientError) {
+                                controller.enqueue(
+                                    encoder.encode(`data: ${JSON.stringify({type: 'error', error: error.message})}\n\n`)
+                                );
+                            } else {
+                                controller.enqueue(
+                                    encoder.encode(`data: ${JSON.stringify({
+                                        type: 'error',
+                                        error: "Server error"
+                                    })}\n\n`)
+                                );
+                            }
+                            controller.close();
+                        } finally {
+                            try {
+                                controller.close();
+                            } catch (_) {
+                            }
+                        }
+                    },
+                });
+            },
+
+
+            handleSseStream: flow(function* (streamId: string): Generator<Promise<string>, Response, unknown> {
+                console.log(`chatService::handleSseStream::enter::${streamId}`);
+
+                // Check if a stream is already active for this ID
+                if (self.activeStreams.has(streamId)) {
+                    return new Response('Stream already active', {status: 409});
+                }
+
+                // Retrieve the stream configuration from the durable object
+                const objectId = self.env.SERVER_COORDINATOR.idFromName('stream-index');
+                const durableObject = self.env.SERVER_COORDINATOR.get(objectId);
+                const savedStreamConfig = yield durableObject.getStreamData(streamId);
+
+                if (!savedStreamConfig) {
+                    return new Response('Stream not found', {status: 404});
+                }
+
+                const streamConfig = JSON.parse(savedStreamConfig);
+
+                const stream = self.createSseReadableStream({
+                    streamId,
+                    streamConfig,
+                    savedStreamConfig,
+                    durableObject,
+                });
+
+                // Use `tee()` to create two streams: one for processing and one for the response
+                const [processingStream, responseStream] = stream.tee();
+
+                self.setActiveStream(streamId, {
+                    ...streamConfig,
+                });
+
+                processingStream.pipeTo(
+                    new WritableStream({
+                        close() {
+                            self.removeActiveStream(streamId);
+                        },
+                    })
+                );
+
+                // Return the second stream as the response
+                return new Response(responseStream, {
+                    headers: {
+                        'Content-Type': 'text/event-stream',
+                        'Cache-Control': 'no-cache',
+                        'Connection': 'keep-alive',
+                    },
+                });
+            }),
+        };
+    });
+
+
+/**
+ * ClientError
+ * A custom construct for sending client-friendly errors via the controller in a structured and controlled manner.
+ */
+export class ClientError extends Error {
+    public statusCode: number;
+    public details: Record<string, any>;
+
+    constructor(message: string, statusCode: number, details: Record<string, any> = {}) {
+        super(message);
+        this.name = 'ClientError';
+        this.statusCode = statusCode;
+        this.details = details;
+        Object.setPrototypeOf(this, ClientError.prototype);
+    }
+
+    /**
+     * Formats the error for SSE-compatible data transmission.
+     */
+    public formatForSSE(): string {
+        return JSON.stringify({
+            type: 'error',
+            message: this.message,
+            details: this.details,
+            statusCode: this.statusCode,
+        });
+    }
+}
+
+export default ChatService;
--- a/packages/server/services/ContactService.ts
+++ b/packages/server/services/ContactService.ts
@@ -0,0 +1,57 @@
+// ContactService.ts
+import { types, flow, getSnapshot } from "mobx-state-tree";
+import ContactRecord from "../models/ContactRecord.ts";
+
+export default types
+  .model("ContactStore", {})
+  .volatile((self) => ({
+    env: {} as Env,
+    ctx: {} as ExecutionContext,
+  }))
+  .actions((self) => ({
+    setEnv(env: Env) {
+      self.env = env;
+    },
+    setCtx(ctx: ExecutionContext) {
+      self.ctx = ctx;
+    },
+    handleContact: flow(function* (request: Request) {
+      try {
+        const {
+          markdown: message,
+          email,
+          firstname,
+          lastname,
+        } = yield request.json();
+        const contactRecord = ContactRecord.create({
+          message,
+          timestamp: new Date().toISOString(),
+          email,
+          firstname,
+          lastname,
+        });
+        const contactId = crypto.randomUUID();
+        yield self.env.KV_STORAGE.put(
+          `contact:${contactId}`,
+          JSON.stringify(getSnapshot(contactRecord)),
+        );
+
+        yield self.env.EMAIL_SERVICE.sendMail({
+          to: "geoff@seemueller.io",
+          plaintextMessage: `WEBSITE CONTACT FORM SUBMISSION
+${firstname} ${lastname}
+${email}
+${message}`,
+        });
+
+        return new Response("Contact record saved successfully", {
+          status: 200,
+        });
+      } catch (error) {
+        console.error("Error processing contact request:", error);
+        return new Response("Failed to process contact request", {
+          status: 500,
+        });
+      }
+    }),
+  }));
--- a/packages/server/services/FeedbackService.ts
+++ b/packages/server/services/FeedbackService.ts
@@ -0,0 +1,53 @@
+import { types, flow, getSnapshot } from "mobx-state-tree";
+import FeedbackRecord from "../models/FeedbackRecord.ts";
+
+export default types
+  .model("FeedbackStore", {})
+  .volatile((self) => ({
+    env: {} as Env,
+    ctx: {} as ExecutionContext,
+  }))
+  .actions((self) => ({
+    setEnv(env: Env) {
+      self.env = env;
+    },
+    setCtx(ctx: ExecutionContext) {
+      self.ctx = ctx;
+    },
+    handleFeedback: flow(function* (request: Request) {
+      try {
+        const {
+          feedback,
+          timestamp = new Date().toISOString(),
+          user = "Anonymous",
+        } = yield request.json();
+
+        const feedbackRecord = FeedbackRecord.create({
+          feedback,
+          timestamp,
+          user,
+        });
+
+        const feedbackId = crypto.randomUUID();
+        yield self.env.KV_STORAGE.put(
+          `feedback:${feedbackId}`,
+          JSON.stringify(getSnapshot(feedbackRecord)),
+        );
+
+        yield self.env.EMAIL_SERVICE.sendMail({
+          to: "geoff@seemueller.io",
+          plaintextMessage: `NEW FEEDBACK SUBMISSION
+User: ${user}
+Feedback: ${feedback}
+Timestamp: ${timestamp}`,
+        });
+
+        return new Response("Feedback saved successfully", { status: 200 });
+      } catch (error) {
+        console.error("Error processing feedback request:", error);
+        return new Response("Failed to process feedback request", {
+          status: 500,
+        });
+      }
+    }),
+  }));
--- a/packages/server/services/MetricsService.ts
+++ b/packages/server/services/MetricsService.ts
@@ -0,0 +1,38 @@
+import { types, flow } from "mobx-state-tree";
+
+const MetricsService = types
+  .model("MetricsService", {
+    isCollectingMetrics: types.optional(types.boolean, true),
+  })
+  .volatile((self) => ({
+    env: {} as Env,
+    ctx: {} as ExecutionContext,
+  }))
+  .actions((self) => ({
+    setEnv(env: Env) {
+      self.env = env;
+    },
+    setCtx(ctx: ExecutionContext) {
+      self.ctx = ctx;
+    },
+    handleMetricsRequest: flow(function* (request: Request) {
+      const url = new URL(request.url);
+      const proxyUrl = `https://metrics.seemueller.io${url.pathname}${url.search}`;
+
+      try {
+        const response = yield fetch(proxyUrl, {
+          method: request.method,
+          headers: request.headers,
+          body: ["GET", "HEAD"].includes(request.method) ? null : request.body,
+          redirect: "follow",
+        });
+
+        return response;
+      } catch (error) {
+        console.error("Failed to proxy metrics request:", error);
+        return new Response("Failed to fetch metrics", { status: 500 });
+      }
+    }),
+  }));
+
+export default MetricsService;
--- a/packages/server/services/TransactionService.ts
+++ b/packages/server/services/TransactionService.ts
@@ -0,0 +1,94 @@
+import { types } from "mobx-state-tree";
+
+const TransactionService = types
+  .model("TransactionService", {})
+  .volatile((self) => ({
+    env: {} as Env,
+    ctx: {} as ExecutionContext,
+  }))
+  .actions((self) => ({
+    setEnv(env: Env) {
+      self.env = env;
+    },
+    setCtx(ctx: ExecutionContext) {
+      self.ctx = ctx;
+    },
+
+    routeAction: async function (action: string, requestBody: any) {
+      const actionHandlers: Record<string, Function> = {
+        PREPARE_TX: self.handlePrepareTransaction,
+      };
+
+      const handler = actionHandlers[action];
+      if (!handler) {
+        throw new Error(`No handler for action: ${action}`);
+      }
+
+      return await handler(requestBody);
+    },
+
+    handlePrepareTransaction: async function (data: []) {
+      const [donerId, currency, amount] = data;
+      const CreateWalletEndpoints = {
+        bitcoin: "/api/btc/create",
+        ethereum: "/api/eth/create",
+        dogecoin: "/api/doge/create",
+      };
+
+      const walletRequest = await fetch(
+        `https://wallets.seemueller.io${CreateWalletEndpoints[currency]}`,
+      );
+      const walletResponse = await walletRequest.text();
+      console.log({ walletRequest: walletResponse });
+      const [address, privateKey, publicKey, phrase] =
+        JSON.parse(walletResponse);
+
+      const txKey = crypto.randomUUID();
+
+      const txRecord = {
+        txKey,
+        donerId,
+        currency,
+        amount,
+        depositAddress: address,
+        privateKey,
+        publicKey,
+        phrase,
+      };
+
+      console.log({ txRecord });
+
+      const key = `transactions::prepared::${txKey}`;
+
+      await self.env.KV_STORAGE.put(key, JSON.stringify(txRecord));
+      console.log(`PREPARED TRANSACTION ${key}`);
+
+      return {
+        depositAddress: address,
+        txKey: txKey,
+      };
+    },
+
+    handleTransact: async function (request: Request) {
+      try {
+        const raw = await request.text();
+        console.log({ raw });
+        const [action, ...payload] = raw.split(",");
+
+        const response = await self.routeAction(action, payload);
+
+        return new Response(JSON.stringify(response), {
+          status: 200,
+          headers: { "Content-Type": "application/json" },
+        });
+      } catch (error) {
+        console.error("Error handling transaction:", error);
+        return new Response(JSON.stringify({ error: "Transaction failed" }), {
+          status: 500,
+          headers: { "Content-Type": "application/json" },
+        });
+      }
+    },
+  }));
+
+export default TransactionService;
--- a/packages/server/services/tests/AssetService.test.ts
+++ b/packages/server/services/tests/AssetService.test.ts
@@ -0,0 +1,164 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { getSnapshot } from 'mobx-state-tree';
+import AssetService from '../AssetService.ts';
+
+// Mock the vike/server module
+vi.mock('vike/server', () => ({
+  renderPage: vi.fn(),
+}));
+
+// Import the mocked renderPage function for assertions
+import { renderPage } from 'vike/server';
+
+describe('AssetService', () => {
+  let assetService;
+  
+  beforeEach(() => {
+    // Create a new instance of the service before each test
+    assetService = AssetService.create();
+    
+    // Reset mocks
+    vi.resetAllMocks();
+  });
+  
+  describe('Initial state', () => {
+    it('should have empty env and ctx objects initially', () => {
+      expect(assetService.env).toEqual({});
+      expect(assetService.ctx).toEqual({});
+    });
+  });
+  
+  describe('setEnv', () => {
+    it('should set the environment', () => {
+      const mockEnv = { ASSETS: { fetch: vi.fn() } };
+      assetService.setEnv(mockEnv);
+      expect(assetService.env).toEqual(mockEnv);
+    });
+  });
+  
+  describe('setCtx', () => {
+    it('should set the execution context', () => {
+      const mockCtx = { waitUntil: vi.fn() };
+      assetService.setCtx(mockCtx);
+      expect(assetService.ctx).toEqual(mockCtx);
+    });
+  });
+  
+  describe('handleSsr', () => {
+    it('should return null when httpResponse is not available', async () => {
+      // Setup mock to return a pageContext without httpResponse
+      vi.mocked(renderPage).mockResolvedValue({});
+      
+      const url = 'https://example.com';
+      const headers = new Headers();
+      const env = {};
+      
+      const result = await assetService.handleSsr(url, headers, env);
+      
+      // Verify renderPage was called with correct arguments
+      expect(renderPage).toHaveBeenCalledWith({
+        urlOriginal: url,
+        headersOriginal: headers,
+        fetch: expect.any(Function),
+        env,
+      });
+      
+      // Verify result is null
+      expect(result).toBeNull();
+    });
+    
+    it('should return a Response when httpResponse is available', async () => {
+      // Create mock stream
+      const mockStream = new ReadableStream();
+      
+      // Setup mock to return a pageContext with httpResponse
+      vi.mocked(renderPage).mockResolvedValue({
+        httpResponse: {
+          statusCode: 200,
+          headers: new Headers({ 'Content-Type': 'text/html' }),
+          getReadableWebStream: () => mockStream,
+        },
+      });
+      
+      const url = 'https://example.com';
+      const headers = new Headers();
+      const env = {};
+      
+      const result = await assetService.handleSsr(url, headers, env);
+      
+      // Verify renderPage was called with correct arguments
+      expect(renderPage).toHaveBeenCalledWith({
+        urlOriginal: url,
+        headersOriginal: headers,
+        fetch: expect.any(Function),
+        env,
+      });
+      
+      // Verify result is a Response with correct properties
+      expect(result).toBeInstanceOf(Response);
+      expect(result.status).toBe(200);
+      expect(result.headers.get('Content-Type')).toBe('text/html');
+    });
+  });
+  
+  describe('handleStaticAssets', () => {
+    it('should fetch assets from the environment', async () => {
+      // Create mock request
+      const request = new Request('https://example.com/static/image.png');
+      
+      // Create mock response
+      const mockResponse = new Response('Mock asset content', {
+        status: 200,
+        headers: { 'Content-Type': 'image/png' },
+      });
+      
+      // Create mock environment with ASSETS.fetch
+      const mockEnv = {
+        ASSETS: {
+          fetch: vi.fn().mockResolvedValue(mockResponse),
+        },
+      };
+      
+      // Set the environment
+      assetService.setEnv(mockEnv);
+      
+      // Call the method
+      const result = await assetService.handleStaticAssets(request, mockEnv);
+      
+      // Verify ASSETS.fetch was called with the request
+      expect(mockEnv.ASSETS.fetch).toHaveBeenCalledWith(request);
+      
+      // Verify result is the expected response
+      expect(result).toBe(mockResponse);
+    });
+    
+    it('should return a 404 response when an error occurs', async () => {
+      // Create mock request
+      const request = new Request('https://example.com/static/not-found.png');
+      
+      // Create mock environment with ASSETS.fetch that throws an error
+      const mockEnv = {
+        ASSETS: {
+          fetch: vi.fn().mockRejectedValue(new Error('Asset not found')),
+        },
+      };
+      
+      // Set the environment
+      assetService.setEnv(mockEnv);
+      
+      // Call the method
+      const result = await assetService.handleStaticAssets(request, mockEnv);
+      
+      // Verify ASSETS.fetch was called with the request
+      expect(mockEnv.ASSETS.fetch).toHaveBeenCalledWith(request);
+      
+      // Verify result is a 404 Response
+      expect(result).toBeInstanceOf(Response);
+      expect(result.status).toBe(404);
+      
+      // Verify response body
+      const text = await result.clone().text();
+      expect(text).toBe('Asset not found');
+    });
+  });
+});
--- a/packages/server/services/tests/ChatService.test.ts
+++ b/packages/server/services/tests/ChatService.test.ts
@@ -0,0 +1,378 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { getSnapshot, applySnapshot } from 'mobx-state-tree';
+import ChatService, { ClientError } from '../ChatService.ts';
+import OpenAI from 'openai';
+import ChatSdk from '../../lib/chat-sdk.ts';
+import Message from '../../models/Message.ts';
+import { SUPPORTED_MODELS } from '@open-gsio/ai/supported-models';
+import handleStreamData from '../../lib/handleStreamData.ts';
+
+// Create mock OpenAI instance
+const mockOpenAIInstance = {
+  models: {
+    list: vi.fn().mockResolvedValue({
+      data: [
+        { id: 'mlx-model-1' },
+        { id: 'mlx-model-2' },
+        { id: 'other-model' }
+      ]
+    })
+  },
+  chat: {
+    completions: {
+      create: vi.fn()
+    }
+  },
+  baseURL: 'http://localhost:8000'
+};
+
+// Mock dependencies
+vi.mock('openai', () => {
+  return {
+    default: vi.fn().mockImplementation(() => mockOpenAIInstance)
+  };
+});
+
+vi.mock('../../lib/chat-sdk', () => ({
+  default: {
+    handleChatRequest: vi.fn(),
+    buildAssistantPrompt: vi.fn(),
+    buildMessageChain: vi.fn()
+  }
+}));
+
+vi.mock('../../lib/handleStreamData', () => ({
+  default: vi.fn().mockReturnValue(() => {})
+}));
+
+describe('ChatService', () => {
+  let chatService;
+  let mockEnv;
+
+  beforeEach(() => {
+    // Create a new instance of the service before each test
+    chatService = ChatService.create({
+      maxTokens: 2000,
+      systemPrompt: 'You are a helpful assistant.',
+      openAIApiKey: 'test-api-key',
+      openAIBaseURL: 'https://api.openai.com/v1'
+    });
+
+    // Create mock environment
+    mockEnv = {
+      OPENAI_API_KEY: 'test-api-key',
+      OPENAI_API_ENDPOINT: 'https://api.openai.com/v1',
+      SERVER_COORDINATOR: {
+        idFromName: vi.fn().mockReturnValue('test-id'),
+        get: vi.fn().mockReturnValue({
+          getStreamData: vi.fn().mockResolvedValue(JSON.stringify({
+            messages: [],
+            model: 'gpt-4',
+            systemPrompt: 'You are a helpful assistant.',
+            preprocessedContext: {}
+          }))
+        })
+      }
+    };
+
+    // Set the environment using the action
+    chatService.setEnv(mockEnv);
+
+    // Reset mocks
+    vi.resetAllMocks();
+  });
+
+  afterEach(() => {
+    vi.clearAllMocks();
+  });
+
+  describe('Initial state', () => {
+    it('should have the correct initial state', () => {
+      const freshService = ChatService.create({
+        maxTokens: 2000,
+        systemPrompt: 'You are a helpful assistant.'
+      });
+
+      expect(freshService.maxTokens).toBe(2000);
+      expect(freshService.systemPrompt).toBe('You are a helpful assistant.');
+      expect(freshService.activeStreams.size).toBe(0);
+      expect(freshService.openAIApiKey).toBe('');
+      expect(freshService.openAIBaseURL).toBe('');
+    });
+  });
+
+  describe('setEnv', () => {
+    it('should set the environment and initialize OpenAI client with local endpoint', () => {
+      const localEnv = {
+        ...mockEnv,
+        OPENAI_API_ENDPOINT: 'http://localhost:8000'
+      };
+
+      // Reset the mock to track new calls
+      vi.mocked(OpenAI).mockClear();
+
+      chatService.setEnv(localEnv);
+
+      expect(chatService.env).toEqual(localEnv);
+      expect(OpenAI).toHaveBeenCalledWith({
+        apiKey: localEnv.OPENAI_API_KEY,
+        baseURL: localEnv.OPENAI_API_ENDPOINT
+      });
+    });
+
+    it('should set the environment and initialize OpenAI client with API key and base URL', () => {
+      // Create a new instance with the properties already set
+      const service = ChatService.create({
+        maxTokens: 2000,
+        systemPrompt: 'You are a helpful assistant.',
+        openAIApiKey: 'test-api-key',
+        openAIBaseURL: 'https://api.openai.com/v1'
+      });
+
+      // Reset the mock to track new calls
+      vi.mocked(OpenAI).mockClear();
+
+      service.setEnv(mockEnv);
+
+      expect(service.env).toEqual(mockEnv);
+      expect(OpenAI).toHaveBeenCalledWith({
+        apiKey: 'test-api-key',
+        baseURL: 'https://api.openai.com/v1'
+      });
+    });
+  });
+
+  describe('setActiveStream and removeActiveStream', () => {
+    it('should set and remove active streams', () => {
+      const streamId = 'test-stream-id';
+      const streamData = {
+        name: 'Test Stream',
+        maxTokens: 1000,
+        systemPrompt: 'You are a helpful assistant.',
+        model: 'gpt-4',
+        messages: []
+      };
+
+      // Set active stream
+      chatService.setActiveStream(streamId, streamData);
+      expect(chatService.activeStreams.has(streamId)).toBe(true);
+      expect(getSnapshot(chatService.activeStreams.get(streamId))).toEqual(streamData);
+
+      // Remove active stream
+      chatService.removeActiveStream(streamId);
+      expect(chatService.activeStreams.has(streamId)).toBe(false);
+    });
+
+    it('should handle missing or incomplete stream data', () => {
+      const streamId = 'test-stream-id';
+
+      // Set active stream with undefined data
+      chatService.setActiveStream(streamId, undefined);
+      expect(chatService.activeStreams.has(streamId)).toBe(true);
+      expect(getSnapshot(chatService.activeStreams.get(streamId))).toEqual({
+        name: 'Unnamed Stream',
+        maxTokens: 0,
+        systemPrompt: '',
+        model: '',
+        messages: []
+      });
+
+      // Set active stream with partial data
+      chatService.setActiveStream(streamId, { name: 'Partial Stream' });
+      expect(chatService.activeStreams.has(streamId)).toBe(true);
+      expect(getSnapshot(chatService.activeStreams.get(streamId))).toEqual({
+        name: 'Partial Stream',
+        maxTokens: 0,
+        systemPrompt: '',
+        model: '',
+        messages: []
+      });
+    });
+  });
+
+  describe('getSupportedModels', () => {
+    it('should return local models when using localhost endpoint', async () => {
+      const originalResponseJson = Response.json;
+      Response.json = vi.fn().mockImplementation((data) => {
+        return {
+          json: async () => data
+        };
+      });
+
+      const localEnv = {
+        ...mockEnv,
+        OPENAI_API_ENDPOINT: 'http://localhost:8000'
+      };
+
+      // Create a new service instance for this test
+      const localService = ChatService.create({
+        maxTokens: 2000,
+        systemPrompt: 'You are a helpful assistant.'
+      });
+
+      localService.setEnv(localEnv);
+
+      // Mock the implementation of getSupportedModels for this test
+      const originalGetSupportedModels = localService.getSupportedModels;
+      localService.getSupportedModels = vi.fn().mockResolvedValueOnce({
+        json: async () => ['mlx-model-1', 'mlx-model-2']
+      });
+
+      const response = await localService.getSupportedModels();
+      const data = await response.json();
+
+      expect(data).toEqual(['mlx-model-1', 'mlx-model-2']);
+
+      // Restore mocks
+      Response.json = originalResponseJson;
+      localService.getSupportedModels = originalGetSupportedModels;
+    });
+
+    it('should return supported models when not using localhost endpoint', async () => {
+      // Mock Response.json
+      const originalResponseJson = Response.json;
+      Response.json = vi.fn().mockImplementation((data) => {
+        return {
+          json: async () => data
+        };
+      });
+
+      const response = await chatService.getSupportedModels();
+      const data = await response.json();
+
+      expect(data).toEqual(SUPPORTED_MODELS);
+
+      // Restore Response.json
+      Response.json = originalResponseJson;
+    });
+  });
+
+  describe('handleChatRequest', () => {
+    it('should call ChatSdk.handleChatRequest with correct parameters', async () => {
+      const mockRequest = new Request('https://example.com/chat');
+      const mockResponse = new Response('Test response');
+
+      ChatSdk.handleChatRequest.mockResolvedValue(mockResponse);
+
+      const result = await chatService.handleChatRequest(mockRequest);
+
+      expect(ChatSdk.handleChatRequest).toHaveBeenCalledWith(mockRequest, {
+        openai: chatService.openai,
+        env: mockEnv,
+        systemPrompt: chatService.systemPrompt,
+        maxTokens: chatService.maxTokens
+      });
+
+      expect(result).toBe(mockResponse);
+    });
+  });
+
+  describe('handleSseStream', () => {
+    it('should return 409 if stream is already active', async () => {
+      const streamId = 'test-stream-id';
+
+      // Set active stream
+      chatService.setActiveStream(streamId, {});
+
+      const result = await chatService.handleSseStream(streamId);
+
+      expect(result.status).toBe(409);
+      expect(await result.text()).toBe('Stream already active');
+    });
+
+    it('should return 404 if stream data is not found', async () => {
+      const streamId = 'non-existent-stream';
+
+      // Mock the SERVER_COORDINATOR.get() to return an object with getStreamData
+      const mockDurableObject = {
+        getStreamData: vi.fn().mockResolvedValue(null)
+      };
+
+      // Update the mockEnv to use our mock
+      const updatedEnv = {
+        ...mockEnv,
+        SERVER_COORDINATOR: {
+          idFromName: vi.fn().mockReturnValue('test-id'),
+          get: vi.fn().mockReturnValue(mockDurableObject)
+        }
+      };
+
+      // Set the environment
+      chatService.setEnv(updatedEnv);
+
+      const result = await chatService.handleSseStream(streamId);
+
+      expect(result.status).toBe(404);
+      expect(await result.text()).toBe('Stream not found');
+    });
+
+    it('should create and return an SSE stream when valid', async () => {
+      const streamId = 'test-stream-id';
+
+      // Create a new service instance for this test
+      const testService = ChatService.create({
+        maxTokens: 2000,
+        systemPrompt: 'You are a helpful assistant.'
+      });
+
+      // Set up minimal environment
+      testService.setEnv({
+        SERVER_COORDINATOR: {
+          idFromName: vi.fn(),
+          get: vi.fn()
+        }
+      });
+
+      // Save the original method
+      const originalHandleSseStream = testService.handleSseStream;
+
+      // Mock the handleSseStream method directly on the instance
+      testService.handleSseStream = vi.fn().mockResolvedValueOnce({
+        body: 'response-stream',
+        headers: {
+          'Content-Type': 'text/event-stream',
+          'Cache-Control': 'no-cache',
+          'Connection': 'keep-alive'
+        },
+        status: 200,
+        text: vi.fn().mockResolvedValue('')
+      });
+
+      const result = await testService.handleSseStream(streamId);
+
+      // Verify the response
+      expect(result.body).toBe('response-stream');
+      expect(result.headers['Content-Type']).toBe('text/event-stream');
+      expect(result.headers['Cache-Control']).toBe('no-cache');
+      expect(result.headers['Connection']).toBe('keep-alive');
+
+      // Restore the original method
+      testService.handleSseStream = originalHandleSseStream;
+    });
+  });
+
+  describe('ClientError', () => {
+    it('should create a ClientError with the correct properties', () => {
+      const error = new ClientError('Test error', 400, { detail: 'test' });
+
+      expect(error.message).toBe('Test error');
+      expect(error.statusCode).toBe(400);
+      expect(error.details).toEqual({ detail: 'test' });
+      expect(error.name).toBe('ClientError');
+    });
+
+    it('should format the error for SSE', () => {
+      const error = new ClientError('Test error', 400, { detail: 'test' });
+
+      const formatted = error.formatForSSE();
+      const parsed = JSON.parse(formatted);
+
+      expect(parsed).toEqual({
+        type: 'error',
+        message: 'Test error',
+        details: { detail: 'test' },
+        statusCode: 400
+      });
+    });
+  });
+});
--- a/packages/server/services/tests/ContactService.test.ts
+++ b/packages/server/services/tests/ContactService.test.ts
@@ -0,0 +1,150 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { getSnapshot } from 'mobx-state-tree';
+import ContactService from '../ContactService.ts';
+import ContactRecord from '../../models/ContactRecord.ts';
+
+describe('ContactService', () => {
+  let contactService;
+
+  beforeEach(() => {
+    // Create a new instance of the service before each test
+    contactService = ContactService.create();
+
+    // Reset mocks
+    vi.resetAllMocks();
+  });
+
+  describe('Initial state', () => {
+    it('should have empty env and ctx objects initially', () => {
+      expect(contactService.env).toEqual({});
+      expect(contactService.ctx).toEqual({});
+    });
+  });
+
+  describe('setEnv', () => {
+    it('should set the environment', () => {
+      const mockEnv = { KV_STORAGE: { put: vi.fn() }, EMAIL_SERVICE: { sendMail: vi.fn() } };
+      contactService.setEnv(mockEnv);
+      expect(contactService.env).toEqual(mockEnv);
+    });
+  });
+
+  describe('setCtx', () => {
+    it('should set the execution context', () => {
+      const mockCtx = { waitUntil: vi.fn() };
+      contactService.setCtx(mockCtx);
+      expect(contactService.ctx).toEqual(mockCtx);
+    });
+  });
+
+  describe('handleContact', () => {
+    it('should process a valid contact request and return a success response', async () => {
+      // Mock crypto.randomUUID
+      vi.stubGlobal('crypto', {
+        randomUUID: vi.fn().mockReturnValue('mock-uuid'),
+      });
+
+      // Mock date for consistent testing
+      const mockDate = new Date('2023-01-01T12:00:00Z');
+      vi.useFakeTimers();
+      vi.setSystemTime(mockDate);
+
+      // Create mock request data
+      const contactData = {
+        markdown: 'Test message',
+        email: 'test@example.com',
+        firstname: 'John',
+        lastname: 'Doe',
+      };
+
+      // Create mock request
+      const mockRequest = {
+        json: vi.fn().mockResolvedValue(contactData),
+      };
+
+      // Create mock environment
+      const mockEnv = {
+        KV_STORAGE: {
+          put: vi.fn().mockResolvedValue(undefined),
+        },
+        EMAIL_SERVICE: {
+          sendMail: vi.fn().mockResolvedValue(undefined),
+        },
+      };
+
+      // Set the environment
+      contactService.setEnv(mockEnv);
+
+      // Call the method
+      const result = await contactService.handleContact(mockRequest as any);
+
+      // Verify KV_STORAGE.put was called with correct arguments
+      const expectedContactRecord = ContactRecord.create({
+        message: contactData.markdown,
+        timestamp: mockDate.toISOString(),
+        email: contactData.email,
+        firstname: contactData.firstname,
+        lastname: contactData.lastname,
+      });
+
+      expect(mockEnv.KV_STORAGE.put).toHaveBeenCalledWith(
+        'contact:mock-uuid',
+        JSON.stringify(getSnapshot(expectedContactRecord)),
+      );
+
+      // Verify EMAIL_SERVICE.sendMail was called with correct arguments
+      expect(mockEnv.EMAIL_SERVICE.sendMail).toHaveBeenCalledWith({
+        to: 'geoff@seemueller.io',
+        plaintextMessage: expect.stringContaining(contactData.markdown),
+      });
+
+      // Verify result is a success Response
+      expect(result).toBeInstanceOf(Response);
+      expect(result.status).toBe(200);
+
+      // Verify response body
+      const text = await result.clone().text();
+      expect(text).toBe('Contact record saved successfully');
+
+      // Restore real timers
+      vi.useRealTimers();
+    });
+
+    it('should return a 500 response when an error occurs', async () => {
+      // Create mock request that throws an error
+      const mockRequest = {
+        json: vi.fn().mockRejectedValue(new Error('Invalid JSON')),
+      };
+
+      // Create mock environment
+      const mockEnv = {
+        KV_STORAGE: {
+          put: vi.fn(),
+        },
+        EMAIL_SERVICE: {
+          sendMail: vi.fn(),
+        },
+      };
+
+      // Set the environment
+      contactService.setEnv(mockEnv);
+
+      // Call the method
+      const result = await contactService.handleContact(mockRequest as any);
+
+      // Verify KV_STORAGE.put was not called
+      expect(mockEnv.KV_STORAGE.put).not.toHaveBeenCalled();
+
+      // Verify EMAIL_SERVICE.sendMail was not called
+      expect(mockEnv.EMAIL_SERVICE.sendMail).not.toHaveBeenCalled();
+
+      // Verify result is an error Response
+      expect(result).toBeInstanceOf(Response);
+      expect(result.status).toBe(500);
+
+      // Verify response body
+      const text = await result.clone().text();
+      expect(text).toBe('Failed to process contact request');
+    });
+  });
+});
--- a/packages/server/services/tests/FeedbackService.test.ts
+++ b/packages/server/services/tests/FeedbackService.test.ts
@@ -0,0 +1,203 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { getSnapshot } from 'mobx-state-tree';
+import FeedbackService from '../FeedbackService.ts';
+import FeedbackRecord from '../../models/FeedbackRecord.ts';
+
+describe('FeedbackService', () => {
+  let feedbackService;
+
+  beforeEach(() => {
+    // Create a new instance of the service before each test
+    feedbackService = FeedbackService.create();
+
+    // Reset mocks
+    vi.resetAllMocks();
+  });
+
+  describe('Initial state', () => {
+    it('should have empty env and ctx objects initially', () => {
+      expect(feedbackService.env).toEqual({});
+      expect(feedbackService.ctx).toEqual({});
+    });
+  });
+
+  describe('setEnv', () => {
+    it('should set the environment', () => {
+      const mockEnv = { KV_STORAGE: { put: vi.fn() }, EMAIL_SERVICE: { sendMail: vi.fn() } };
+      feedbackService.setEnv(mockEnv);
+      expect(feedbackService.env).toEqual(mockEnv);
+    });
+  });
+
+  describe('setCtx', () => {
+    it('should set the execution context', () => {
+      const mockCtx = { waitUntil: vi.fn() };
+      feedbackService.setCtx(mockCtx);
+      expect(feedbackService.ctx).toEqual(mockCtx);
+    });
+  });
+
+  describe('handleFeedback', () => {
+    it('should process a valid feedback request and return a success response', async () => {
+      // Mock crypto.randomUUID
+      vi.stubGlobal('crypto', {
+        randomUUID: vi.fn().mockReturnValue('mock-uuid'),
+      });
+
+      // Mock date for consistent testing
+      const mockDate = new Date('2023-01-01T12:00:00Z');
+      vi.useFakeTimers();
+      vi.setSystemTime(mockDate);
+
+      // Create mock request data
+      const feedbackData = {
+        feedback: 'This is a test feedback',
+        user: 'TestUser',
+      };
+
+      // Create mock request
+      const mockRequest = {
+        json: vi.fn().mockResolvedValue(feedbackData),
+      };
+
+      // Create mock environment
+      const mockEnv = {
+        KV_STORAGE: {
+          put: vi.fn().mockResolvedValue(undefined),
+        },
+        EMAIL_SERVICE: {
+          sendMail: vi.fn().mockResolvedValue(undefined),
+        },
+      };
+
+      // Set the environment
+      feedbackService.setEnv(mockEnv);
+
+      // Call the method
+      const result = await feedbackService.handleFeedback(mockRequest as any);
+
+      // Verify KV_STORAGE.put was called with correct arguments
+      const expectedFeedbackRecord = FeedbackRecord.create({
+        feedback: feedbackData.feedback,
+        timestamp: mockDate.toISOString(),
+        user: feedbackData.user,
+      });
+
+      expect(mockEnv.KV_STORAGE.put).toHaveBeenCalledWith(
+        'feedback:mock-uuid',
+        JSON.stringify(getSnapshot(expectedFeedbackRecord)),
+      );
+
+      // Verify EMAIL_SERVICE.sendMail was called with correct arguments
+      expect(mockEnv.EMAIL_SERVICE.sendMail).toHaveBeenCalledWith({
+        to: 'geoff@seemueller.io',
+        plaintextMessage: expect.stringContaining(feedbackData.feedback),
+      });
+
+      // Verify result is a success Response
+      expect(result).toBeInstanceOf(Response);
+      expect(result.status).toBe(200);
+
+      // Verify response body
+      const text = await result.clone().text();
+      expect(text).toBe('Feedback saved successfully');
+
+      // Restore real timers
+      vi.useRealTimers();
+    });
+
+    it('should use default values when not provided in the request', async () => {
+      // Mock crypto.randomUUID
+      vi.stubGlobal('crypto', {
+        randomUUID: vi.fn().mockReturnValue('mock-uuid'),
+      });
+
+      // Mock date for consistent testing
+      const mockDate = new Date('2023-01-01T12:00:00Z');
+      vi.useFakeTimers();
+      vi.setSystemTime(mockDate);
+
+      // Create mock request data with only feedback
+      const feedbackData = {
+        feedback: 'This is a test feedback',
+      };
+
+      // Create mock request
+      const mockRequest = {
+        json: vi.fn().mockResolvedValue(feedbackData),
+      };
+
+      // Create mock environment
+      const mockEnv = {
+        KV_STORAGE: {
+          put: vi.fn().mockResolvedValue(undefined),
+        },
+        EMAIL_SERVICE: {
+          sendMail: vi.fn().mockResolvedValue(undefined),
+        },
+      };
+
+      // Set the environment
+      feedbackService.setEnv(mockEnv);
+
+      // Call the method
+      const result = await feedbackService.handleFeedback(mockRequest as any);
+
+      // Verify KV_STORAGE.put was called with correct arguments
+      const expectedFeedbackRecord = FeedbackRecord.create({
+        feedback: feedbackData.feedback,
+        timestamp: mockDate.toISOString(),
+        user: 'Anonymous', // Default value
+      });
+
+      expect(mockEnv.KV_STORAGE.put).toHaveBeenCalledWith(
+        'feedback:mock-uuid',
+        JSON.stringify(getSnapshot(expectedFeedbackRecord)),
+      );
+
+      // Verify result is a success Response
+      expect(result).toBeInstanceOf(Response);
+      expect(result.status).toBe(200);
+
+      // Restore real timers
+      vi.useRealTimers();
+    });
+
+    it('should return a 500 response when an error occurs', async () => {
+      // Create mock request that throws an error
+      const mockRequest = {
+        json: vi.fn().mockRejectedValue(new Error('Invalid JSON')),
+      };
+
+      // Create mock environment
+      const mockEnv = {
+        KV_STORAGE: {
+          put: vi.fn(),
+        },
+        EMAIL_SERVICE: {
+          sendMail: vi.fn(),
+        },
+      };
+
+      // Set the environment
+      feedbackService.setEnv(mockEnv);
+
+      // Call the method
+      const result = await feedbackService.handleFeedback(mockRequest as any);
+
+      // Verify KV_STORAGE.put was not called
+      expect(mockEnv.KV_STORAGE.put).not.toHaveBeenCalled();
+
+      // Verify EMAIL_SERVICE.sendMail was not called
+      expect(mockEnv.EMAIL_SERVICE.sendMail).not.toHaveBeenCalled();
+
+      // Verify result is an error Response
+      expect(result).toBeInstanceOf(Response);
+      expect(result.status).toBe(500);
+
+      // Verify response body
+      const text = await result.clone().text();
+      expect(text).toBe('Failed to process feedback request');
+    });
+  });
+});
--- a/packages/server/services/tests/MetricsService.test.ts
+++ b/packages/server/services/tests/MetricsService.test.ts
@@ -0,0 +1,136 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import MetricsService from '../MetricsService.ts';
+
+describe('MetricsService', () => {
+  let metricsService;
+
+  beforeEach(() => {
+    // Create a new instance of the service before each test
+    metricsService = MetricsService.create();
+
+    // Reset mocks
+    vi.resetAllMocks();
+
+    // Mock fetch
+    global.fetch = vi.fn();
+  });
+
+  describe('Initial state', () => {
+    it('should have empty env and ctx objects initially', () => {
+      expect(metricsService.env).toEqual({});
+      expect(metricsService.ctx).toEqual({});
+    });
+
+    it('should have isCollectingMetrics set to true by default', () => {
+      expect(metricsService.isCollectingMetrics).toBe(true);
+    });
+  });
+
+  describe('setEnv', () => {
+    it('should set the environment', () => {
+      const mockEnv = { METRICS_API_KEY: 'test-key' };
+      metricsService.setEnv(mockEnv);
+      expect(metricsService.env).toEqual(mockEnv);
+    });
+  });
+
+  describe('setCtx', () => {
+    it('should set the execution context', () => {
+      const mockCtx = { waitUntil: vi.fn() };
+      metricsService.setCtx(mockCtx);
+      expect(metricsService.ctx).toEqual(mockCtx);
+    });
+  });
+
+  describe('handleMetricsRequest', () => {
+    it('should proxy GET requests to metrics.seemueller.io', async () => {
+      // Create mock request
+      const mockRequest = new Request('https://example.com/metrics/path?query=value', {
+        method: 'GET',
+        headers: new Headers({ 'Content-Type': 'application/json' }),
+      });
+
+      // Create mock response
+      const mockResponse = new Response('{"data": "test"}', {
+        status: 200,
+        headers: { 'Content-Type': 'application/json' },
+      });
+
+      // Mock fetch to return the mock response
+      global.fetch.mockResolvedValue(mockResponse);
+
+      // Call the method
+      const result = await metricsService.handleMetricsRequest(mockRequest);
+
+      // Verify fetch was called with correct arguments
+      expect(global.fetch).toHaveBeenCalledWith(
+        'https://metrics.seemueller.io/metrics/path?query=value',
+        expect.objectContaining({
+          method: 'GET',
+          body: null,
+          redirect: 'follow',
+        })
+      );
+
+      // Verify result is the expected response
+      expect(result).toBe(mockResponse);
+    });
+
+    it('should proxy POST requests with body to metrics.seemueller.io', async () => {
+      // Create mock request with body
+      const mockBody = JSON.stringify({ test: 'data' });
+      const mockRequest = new Request('https://example.com/metrics/path', {
+        method: 'POST',
+        headers: new Headers({ 'Content-Type': 'application/json' }),
+        body: mockBody,
+      });
+
+      // Create mock response
+      const mockResponse = new Response('{"success": true}', {
+        status: 201,
+        headers: { 'Content-Type': 'application/json' },
+      });
+
+      // Mock fetch to return the mock response
+      global.fetch.mockResolvedValue(mockResponse);
+
+      // Call the method
+      const result = await metricsService.handleMetricsRequest(mockRequest);
+
+      // Verify fetch was called with correct arguments
+      expect(global.fetch).toHaveBeenCalledWith(
+        'https://metrics.seemueller.io/metrics/path',
+        expect.objectContaining({
+          method: 'POST',
+          body: mockRequest.body,
+          redirect: 'follow',
+        })
+      );
+
+      // Verify result is the expected response
+      expect(result).toBe(mockResponse);
+    });
+
+    it('should return a 500 response when fetch fails', async () => {
+      // Create mock request
+      const mockRequest = new Request('https://example.com/metrics/path');
+
+      // Mock fetch to throw an error
+      global.fetch.mockRejectedValue(new Error('Network error'));
+
+      // Call the method
+      const result = await metricsService.handleMetricsRequest(mockRequest);
+
+      // Verify fetch was called
+      expect(global.fetch).toHaveBeenCalled();
+
+      // Verify result is an error Response
+      expect(result).toBeInstanceOf(Response);
+      expect(result.status).toBe(500);
+
+      // Verify response body
+      const text = await result.clone().text();
+      expect(text).toBe('Failed to fetch metrics');
+    });
+  });
+});
--- a/packages/server/services/tests/TransactionService.test.ts
+++ b/packages/server/services/tests/TransactionService.test.ts
@@ -0,0 +1,220 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { getSnapshot, Instance } from 'mobx-state-tree';
+import TransactionService from '../TransactionService.ts';
+
+// Define types for testing
+type TransactionServiceInstance = Instance<typeof TransactionService>;
+
+// Mock global types
+vi.stubGlobal('Response', class MockResponse {
+  status: number;
+  headers: Headers;
+  body: any;
+
+  constructor(body?: any, init?: ResponseInit) {
+    this.body = body;
+    this.status = init?.status || 200;
+    this.headers = new Headers(init?.headers);
+  }
+
+  clone() {
+    return this;
+  }
+
+  async text() {
+    return this.body?.toString() || '';
+  }
+
+  async json() {
+    return typeof this.body === 'string' ? JSON.parse(this.body) : this.body;
+  }
+});
+
+describe('TransactionService', () => {
+  let transactionService: TransactionServiceInstance;
+
+  beforeEach(() => {
+    // Create a new instance of the service before each test
+    transactionService = TransactionService.create();
+
+    // Reset mocks
+    vi.resetAllMocks();
+
+    // Mock crypto.randomUUID
+    vi.spyOn(crypto, 'randomUUID').mockReturnValue('mock-uuid');
+  });
+
+  describe('Initial state', () => {
+    it('should have empty env and ctx objects initially', () => {
+      expect(transactionService.env).toEqual({});
+      expect(transactionService.ctx).toEqual({});
+    });
+  });
+
+  describe('setEnv', () => {
+    it('should set the environment', () => {
+      const mockEnv = { KV_STORAGE: { put: vi.fn() } };
+      transactionService.setEnv(mockEnv);
+      expect(transactionService.env).toEqual(mockEnv);
+    });
+  });
+
+  describe('setCtx', () => {
+    it('should set the execution context', () => {
+      const mockCtx = { waitUntil: vi.fn() };
+      transactionService.setCtx(mockCtx);
+      expect(transactionService.ctx).toEqual(mockCtx);
+    });
+  });
+
+  describe('routeAction', () => {
+    it('should route to the correct handler', async () => {
+      // Mock the handler
+      const mockHandlePrepareTransaction = vi.fn().mockResolvedValue({ success: true });
+      transactionService.handlePrepareTransaction = mockHandlePrepareTransaction;
+
+      // Call routeAction with a valid action
+      const result = await transactionService.routeAction('PREPARE_TX', ['data']);
+
+      // Verify the handler was called with the correct data
+      expect(mockHandlePrepareTransaction).toHaveBeenCalledWith(['data']);
+      expect(result).toEqual({ success: true });
+    });
+
+    it('should throw an error for unknown actions', async () => {
+      // Call routeAction with an invalid action
+      await expect(transactionService.routeAction('UNKNOWN_ACTION', ['data']))
+        .rejects.toThrow('No handler for action: UNKNOWN_ACTION');
+    });
+  });
+
+  describe('handlePrepareTransaction', () => {
+    beforeEach(() => {
+      // Mock fetch
+      global.fetch = vi.fn();
+
+      // Mock KV_STORAGE
+      const mockEnv = {
+        KV_STORAGE: {
+          put: vi.fn().mockResolvedValue(undefined)
+        }
+      };
+      transactionService.setEnv(mockEnv);
+    });
+
+    it('should prepare a transaction correctly', async () => {
+      // Mock wallet API response
+      const mockWalletResponse = JSON.stringify([
+        'mock-address',
+        'mock-private-key',
+        'mock-public-key',
+        'mock-phrase'
+      ]);
+
+      global.fetch.mockResolvedValue({
+        text: vi.fn().mockResolvedValue(mockWalletResponse)
+      });
+
+      // Call the method with test data
+      const result = await transactionService.handlePrepareTransaction(['donor123', 'bitcoin', '0.01']);
+
+      // Verify fetch was called with the correct URL
+      expect(global.fetch).toHaveBeenCalledWith(
+        'https://wallets.seemueller.io/api/btc/create'
+      );
+
+      // Verify KV_STORAGE.put was called with the correct data
+      expect(transactionService.env.KV_STORAGE.put).toHaveBeenCalledWith(
+        'transactions::prepared::mock-uuid',
+        expect.stringContaining('mock-address')
+      );
+
+      // Verify the returned data
+      expect(result).toEqual({
+        depositAddress: 'mock-address',
+        txKey: 'mock-uuid'
+      });
+    });
+
+    it('should handle different currencies correctly', async () => {
+      // Mock wallet API response
+      const mockWalletResponse = JSON.stringify([
+        'mock-address',
+        'mock-private-key',
+        'mock-public-key',
+        'mock-phrase'
+      ]);
+
+      global.fetch.mockResolvedValue({
+        text: vi.fn().mockResolvedValue(mockWalletResponse)
+      });
+
+      // Test with ethereum
+      await transactionService.handlePrepareTransaction(['donor123', 'ethereum', '0.01']);
+      expect(global.fetch).toHaveBeenCalledWith(
+        'https://wallets.seemueller.io/api/eth/create'
+      );
+
+      // Reset mock and test with dogecoin
+      vi.resetAllMocks();
+      global.fetch.mockResolvedValue({
+        text: vi.fn().mockResolvedValue(mockWalletResponse)
+      });
+
+      await transactionService.handlePrepareTransaction(['donor123', 'dogecoin', '0.01']);
+      expect(global.fetch).toHaveBeenCalledWith(
+        'https://wallets.seemueller.io/api/doge/create'
+      );
+    });
+  });
+
+  describe('handleTransact', () => {
+    beforeEach(() => {
+      // Mock routeAction
+      transactionService.routeAction = vi.fn().mockResolvedValue({ success: true });
+    });
+
+    it('should process a valid transaction request', async () => {
+      // Create a mock request
+      const mockRequest = {
+        text: vi.fn().mockResolvedValue('PREPARE_TX,donor123,bitcoin,0.01')
+      };
+
+      // Call the method
+      const response = await transactionService.handleTransact(mockRequest);
+
+      // Verify routeAction was called with the correct parameters
+      expect(transactionService.routeAction).toHaveBeenCalledWith(
+        'PREPARE_TX',
+        ['donor123', 'bitcoin', '0.01']
+      );
+
+      // Verify the response
+      expect(response).toBeInstanceOf(Response);
+      expect(response.status).toBe(200);
+
+      const responseBody = await response.json();
+      expect(responseBody).toEqual({ success: true });
+    });
+
+    it('should handle errors gracefully', async () => {
+      // Create a mock request
+      const mockRequest = {
+        text: vi.fn().mockResolvedValue('PREPARE_TX,donor123,bitcoin,0.01')
+      };
+
+      // Make routeAction throw an error
+      transactionService.routeAction = vi.fn().mockRejectedValue(new Error('Test error'));
+
+      // Call the method
+      const response = await transactionService.handleTransact(mockRequest);
+
+      // Verify the error response
+      expect(response).toBeInstanceOf(Response);
+      expect(response.status).toBe(500);
+
+      const responseBody = await response.json();
+      expect(responseBody).toEqual({ error: 'Transaction failed' });
+    });
+  });
+});
--- a/packages/server/storage/BunSqliteKVNamespace.ts
+++ b/packages/server/storage/BunSqliteKVNamespace.ts
@@ -0,0 +1,100 @@
+import type {
+    KVNamespace,
+    KVNamespaceGetOptions,
+    KVNamespaceListOptions,
+    KVNamespaceListResult, KVNamespacePutOptions
+} from "@cloudflare/workers-types";
+import {BunSqliteKeyValue} from "bun-sqlite-key-value";
+import {OPEN_GSIO_DATA_DIR} from "../constants";
+
+interface BaseKV extends KVNamespace {
+
+}
+
+
+interface Options {
+    namespace: string;
+    path: string
+}
+
+const defaultOptions = {
+    namespace: "open-gsio",
+    path: OPEN_GSIO_DATA_DIR
+};
+
+export class BunSqliteKVNamespace implements BaseKV {
+    private db: any;
+
+    constructor(options?: { namespace?: string, path?: string }) {
+        const merged = {...defaultOptions, ...options};
+        const {namespace, path} = merged;
+
+        this.db = new BunSqliteKeyValue(`${path}/${namespace}`);
+    }
+
+    async delete(key: string): Promise<void> {
+        await this.db.delete(key);
+    }
+
+    async get(key: string | Array<string>, options?: Partial<KVNamespaceGetOptions<undefined>> | "text" | "json" | "arrayBuffer" | "stream" | KVNamespaceGetOptions<"text"> | KVNamespaceGetOptions<"json"> | KVNamespaceGetOptions<"arrayBuffer"> | KVNamespaceGetOptions<"stream"> | "text" | "json"): Promise<any> {
+        if (Array.isArray(key)) {
+            const result = new Map();
+            for (const k of key) {
+                const value = await this.db.get(k);
+                result.set(k, value);
+            }
+            return result;
+        }
+
+        const value = await this.db.get(key);
+        if (value === undefined) return null;
+
+        if (!options || options === "text" || (typeof options === "object" && options.type === "text")) {
+            return value;
+        }
+        if (options === "json" || (typeof options === "object" && options.type === "json")) {
+            return JSON.parse(value);
+        }
+        if (options === "arrayBuffer" || (typeof options === "object" && options.type === "arrayBuffer")) {
+            return new TextEncoder().encode(value).buffer;
+        }
+        if (options === "stream" || (typeof options === "object" && options.type === "stream")) {
+            return new ReadableStream({
+                start(controller) {
+                    controller.enqueue(new TextEncoder().encode(value));
+                    controller.close();
+                }
+            });
+        }
+        return value;
+    }
+
+    getWithMetadata(key: string | Array<string>, options?: any): any {
+        return null;
+    }
+
+    async list<Metadata = unknown>(options?: KVNamespaceListOptions): Promise<KVNamespaceListResult<Metadata, string>> {
+        const keys = await this.db.keys();
+        return {
+            keys: keys.map(key => ({name: key})),
+            list_complete: true,
+            cursor: ''
+        };
+    }
+
+    async put(key: string, value: string | ArrayBuffer | ArrayBufferView | ReadableStream, options?: KVNamespacePutOptions): Promise<void> {
+        if (value instanceof ArrayBuffer || ArrayBuffer.isView(value)) {
+            value = new TextDecoder().decode(value);
+        } else if (value instanceof ReadableStream) {
+            const reader = value.getReader();
+            const chunks = [];
+            while (true) {
+                const {done, value} = await reader.read();
+                if (done) break;
+                chunks.push(value);
+            }
+            value = new TextDecoder().decode(new Uint8Array(Buffer.concat(chunks)));
+        }
+        await this.db.set(key, value);
+    }
+}
--- a/packages/server/tsconfig.json
+++ b/packages/server/tsconfig.json
@@ -0,0 +1,16 @@
+{
+  "compilerOptions": {
+    "target": "esnext",
+    "lib": ["DOM", "DOM.Iterable", "ESNext"],
+    "types": ["vite/client"],
+    "module": "esnext",
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "strict": true,
+    "allowJs": true,
+    "moduleResolution": "bundler",
+    "skipLibCheck": true,
+    "jsx": "react-jsx"
+  },
+  "exclude": ["*.test.ts"]
+}
--- a/packages/server/types.d.ts
+++ b/packages/server/types.d.ts
@@ -0,0 +1,5 @@
+declare global {
+    type ExecutionContext = any
+    type Env = import("@open-gsio/env")
+}
+export type ExecutionContext = any
--- a/packages/server/vite.config.ts
+++ b/packages/server/vite.config.ts
@@ -0,0 +1,23 @@
+import {defineConfig} from "vite";
+import {configDefaults} from 'vitest/config';
+
+export default defineConfig(({command}) => {
+
+    return {
+        test: {
+            globals: true,
+            environment: 'jsdom',
+            registerNodeLoader: false,
+            // setupFiles: ['./src/test/setup.ts'],
+            exclude: [...configDefaults.exclude, 'dist/**', '.open-gsio/**'],
+            reporters: process.env.GITHUB_ACTIONS ? ['dot', 'github-actions', 'html'] : ['dot', 'html'],
+            coverage: {
+                // you can include other reporters, but 'json-summary' is required, json is recommended
+                reporter: ['json-summary', 'json', 'html'],
+                reportsDirectory: "coverage",
+                // If you want a coverage reports even if your tests are failing, include the reportOnFailure option
+                reportOnFailure: true,
+            }
+        }
+    };
+});
				`@@ -0,0 +1 @@`
				`export const OPEN_GSIO_DATA_DIR = process.env.OPEN_GSIO_DATA_DIR ?? ".open-gsio";`