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

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();
+  });
+});