@pioneer-platform/pioneer-inference 1.0.0

package/README.md

@@ -0,0 +1,145 @@
+# @pioneer-platform/pioneer-inference
+
+LLM inference abstraction layer for the Pioneer platform. Provides a unified interface for working with multiple LLM providers (OpenAI, Anthropic, Ollama, etc.).
+
+## Installation
+
+```bash
+npm install @pioneer-platform/pioneer-inference
+```
+
+## Usage
+
+### Basic Usage
+
+```typescript
+import { InferenceClient } from '@pioneer-platform/pioneer-inference';
+
+const client = new InferenceClient({
+  provider: 'openai',
+  apiKey: process.env.OPENAI_API_KEY,
+});
+
+// Set system prompt
+client.setSystemPrompt('You are a helpful coding assistant.');
+
+// Send a message
+const response = await client.chat('Help me write a function');
+console.log(response);
+```
+
+### Point to Custom Endpoint
+
+```typescript
+const client = new InferenceClient({
+  provider: 'openai',
+  apiKey: 'any-key',
+  baseURL: 'http://127.0.0.1:9101/v1', // Your custom OpenAI-compatible endpoint
+  defaultModel: 'gpt-4-turbo-preview',
+});
+```
+
+### Using with Pioneer Server
+
+```typescript
+import { InferenceClient } from '@pioneer-platform/pioneer-inference';
+
+// Point to pioneer-server's OpenAI-compatible endpoint
+const client = new InferenceClient({
+  provider: 'openai',
+  apiKey: 'not-used', // Pioneer server handles auth differently
+  baseURL: 'http://127.0.0.1:9101/v1',
+});
+
+const response = await client.chat('What can you help me with?');
+```
+
+### Full Control with Chat Completions
+
+```typescript
+const response = await client.chatCompletion({
+  model: 'gpt-4-turbo-preview',
+  messages: [
+    { role: 'system', content: 'You are a helpful assistant.' },
+    { role: 'user', content: 'Hello!' },
+  ],
+  temperature: 0.7,
+  max_tokens: 500,
+});
+
+console.log(response.choices[0].message.content);
+```
+
+### Conversation History Management
+
+```typescript
+// Get history
+const history = client.getHistory();
+
+// Clear history (keep system prompt)
+client.clearHistory(true);
+
+// Clear everything
+client.clearHistory(false);
+
+// Get message count
+const count = client.getMessageCount();
+```
+
+## API
+
+### InferenceClient
+
+#### Constructor
+
+```typescript
+new InferenceClient(config: InferenceConfig)
+```
+
+**InferenceConfig:**
+- `provider`: `'openai' | 'anthropic' | 'ollama' | 'custom'`
+- `apiKey?`: API key for the provider
+- `baseURL?`: Custom base URL (for OpenAI-compatible endpoints)
+- `defaultModel?`: Default model to use
+- `timeout?`: Request timeout in milliseconds (default: 60000)
+
+#### Methods
+
+- `chat(message: string, options?: Partial<ChatCompletionRequest>): Promise<string>`
+  - Send a chat message and get a response
+
+- `chatCompletion(request: ChatCompletionRequest): Promise<ChatCompletionResponse>`
+  - Full control over chat completion request
+
+- `setSystemPrompt(prompt: string): void`
+  - Set or update the system prompt
+
+- `clearHistory(keepSystemPrompt?: boolean): void`
+  - Clear conversation history
+
+- `getHistory(): Message[]`
+  - Get conversation history
+
+- `getMessageCount(): number`
+  - Get message count (excluding system messages)
+
+- `isConfigured(): boolean`
+  - Check if provider is properly configured
+
+- `getProviderName(): string`
+  - Get the current provider name
+
+## Supported Providers
+
+### OpenAI (Implemented)
+- Native OpenAI API support
+- Custom OpenAI-compatible endpoints (like pioneer-server)
+
+### Coming Soon
+- Anthropic (Claude)
+- Ollama (local models)
+- Custom providers
+
+## License
+
+MIT

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@pioneer-platform/pioneer-inference",
+  "version": "1.0.0",
+  "description": "LLM inference abstraction layer for Pioneer platform",
+  "main": "./lib/index.js",
+  "types": "./lib/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./lib/index.d.ts",
+      "default": "./lib/index.js"
+    }
+  },
+  "scripts": {
+    "build": "tsc -p .",
+    "build:watch": "tsc -p . --watch",
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "prepublish": "npm run build"
+  },
+  "keywords": [
+    "ai",
+    "llm",
+    "openai",
+    "inference",
+    "pioneer"
+  ],
+  "author": "Pioneer Platform",
+  "license": "MIT",
+  "dependencies": {
+    "openai": "^4.26.0"
+  },
+  "peerDependencies": {},
+  "devDependencies": {
+    "@types/node": "^20.11.16",
+    "typescript": "^5.3.3"
+  }
+}

package/src/index.ts

@@ -0,0 +1,30 @@
+/**
+ * Pioneer Inference
+ *
+ * LLM inference abstraction layer for Pioneer platform
+ *
+ * @example
+ * ```typescript
+ * import { InferenceClient } from '@pioneer-platform/pioneer-inference';
+ *
+ * const client = new InferenceClient({
+ *   provider: 'openai',
+ *   apiKey: process.env.OPENAI_API_KEY,
+ * });
+ *
+ * client.setSystemPrompt('You are a helpful assistant.');
+ * const response = await client.chat('Hello!');
+ * console.log(response);
+ * ```
+ */
+
+export { InferenceClient } from './inference';
+export { OpenAIProvider } from './providers/openai';
+
+export type {
+  Message,
+  ChatCompletionRequest,
+  ChatCompletionResponse,
+  InferenceProvider,
+  InferenceConfig,
+} from './types';

package/src/inference.ts

@@ -0,0 +1,138 @@
+/**
+ * Main Inference Client
+ *
+ * Provides a unified interface for LLM inference across multiple providers
+ */
+
+import type {
+  InferenceConfig,
+  InferenceProvider,
+  ChatCompletionRequest,
+  ChatCompletionResponse,
+  Message,
+} from './types';
+import { OpenAIProvider } from './providers/openai';
+
+export class InferenceClient {
+  private provider: InferenceProvider;
+  private conversationHistory: Message[] = [];
+
+  constructor(config: InferenceConfig) {
+    this.provider = this.createProvider(config);
+  }
+
+  private createProvider(config: InferenceConfig): InferenceProvider {
+    switch (config.provider) {
+      case 'openai':
+        if (!config.apiKey) {
+          throw new Error('OpenAI API key is required');
+        }
+        return new OpenAIProvider({
+          apiKey: config.apiKey,
+          baseURL: config.baseURL,
+          timeout: config.timeout,
+          defaultModel: config.defaultModel,
+        });
+
+      case 'anthropic':
+        throw new Error('Anthropic provider not yet implemented');
+
+      case 'ollama':
+        throw new Error('Ollama provider not yet implemented');
+
+      case 'custom':
+        throw new Error('Custom provider requires implementation');
+
+      default:
+        throw new Error(`Unknown provider: ${config.provider}`);
+    }
+  }
+
+  /**
+   * Send a chat message
+   */
+  async chat(message: string, options?: Partial<ChatCompletionRequest>): Promise<string> {
+    // Add user message to history
+    this.conversationHistory.push({
+      role: 'user',
+      content: message,
+    });
+
+    const request: ChatCompletionRequest = {
+      model: options?.model || 'gpt-4-turbo-preview',
+      messages: this.conversationHistory,
+      ...options,
+    };
+
+    const response = await this.provider.chat(request);
+    const assistantMessage = response.choices[0]?.message?.content || '';
+
+    // Add assistant response to history
+    this.conversationHistory.push({
+      role: 'assistant',
+      content: assistantMessage,
+    });
+
+    return assistantMessage;
+  }
+
+  /**
+   * Send a chat completion request with full control
+   */
+  async chatCompletion(request: ChatCompletionRequest): Promise<ChatCompletionResponse> {
+    return this.provider.chat(request);
+  }
+
+  /**
+   * Set system prompt
+   */
+  setSystemPrompt(prompt: string): void {
+    // Remove existing system message if any
+    this.conversationHistory = this.conversationHistory.filter(m => m.role !== 'system');
+
+    // Add new system message at the beginning
+    this.conversationHistory.unshift({
+      role: 'system',
+      content: prompt,
+    });
+  }
+
+  /**
+   * Clear conversation history (optionally keep system prompt)
+   */
+  clearHistory(keepSystemPrompt: boolean = true): void {
+    if (keepSystemPrompt) {
+      this.conversationHistory = this.conversationHistory.filter(m => m.role === 'system');
+    } else {
+      this.conversationHistory = [];
+    }
+  }
+
+  /**
+   * Get conversation history
+   */
+  getHistory(): Message[] {
+    return [...this.conversationHistory];
+  }
+
+  /**
+   * Get message count (excluding system messages)
+   */
+  getMessageCount(): number {
+    return this.conversationHistory.filter(m => m.role !== 'system').length;
+  }
+
+  /**
+   * Check if provider is configured
+   */
+  isConfigured(): boolean {
+    return this.provider.isConfigured();
+  }
+
+  /**
+   * Get provider name
+   */
+  getProviderName(): string {
+    return this.provider.name;
+  }
+}

package/src/providers/openai.ts

@@ -0,0 +1,69 @@
+/**
+ * OpenAI Provider Implementation
+ */
+
+import OpenAI from 'openai';
+import type {
+  InferenceProvider,
+  ChatCompletionRequest,
+  ChatCompletionResponse,
+} from '../types';
+
+export interface OpenAIConfig {
+  apiKey: string;
+  baseURL?: string;
+  timeout?: number;
+  defaultModel?: string;
+}
+
+export class OpenAIProvider implements InferenceProvider {
+  public readonly name = 'openai';
+  private client: OpenAI;
+  private config: OpenAIConfig;
+
+  constructor(config: OpenAIConfig) {
+    this.config = config;
+    this.client = new OpenAI({
+      apiKey: config.apiKey,
+      baseURL: config.baseURL,
+      timeout: config.timeout || 60000,
+    });
+  }
+
+  async chat(request: ChatCompletionRequest): Promise<ChatCompletionResponse> {
+    try {
+      // Forward ALL parameters from request to OpenAI
+      // This includes tools, tool_choice, and any other OpenAI-specific params
+      const { model, messages, ...extraParams } = request;
+
+      const completion = await this.client.chat.completions.create({
+        model: model || this.config.defaultModel || 'gpt-4-turbo-preview',
+        messages: messages as any,
+        ...extraParams, // Forward all extra parameters (tools, tool_choice, etc.)
+      });
+
+      // Convert OpenAI response to our standard format
+      return completion as ChatCompletionResponse;
+    } catch (error) {
+      if (error instanceof OpenAI.APIError) {
+        throw new Error(`OpenAI API Error: ${error.message}`);
+      }
+      throw error;
+    }
+  }
+
+  isConfigured(): boolean {
+    return !!this.config.apiKey;
+  }
+
+  /**
+   * Update the base URL (useful for pointing to different endpoints)
+   */
+  setBaseURL(baseURL: string): void {
+    this.client = new OpenAI({
+      apiKey: this.config.apiKey,
+      baseURL,
+      timeout: this.config.timeout,
+    });
+  }
+}

package/src/types.ts

@@ -0,0 +1,55 @@
+/**
+ * Common types for LLM inference
+ */
+
+export interface Message {
+  role: 'system' | 'user' | 'assistant' | 'tool';
+  content: string | null;
+  tool_calls?: any[];
+  tool_call_id?: string;
+  name?: string;
+}
+
+export interface ChatCompletionRequest {
+  model: string;
+  messages: Message[];
+  temperature?: number;
+  max_tokens?: number;
+  stream?: boolean;
+  [key: string]: any;
+}
+
+export interface ChatCompletionResponse {
+  id: string;
+  object: string;
+  created: number;
+  model: string;
+  choices: Array<{
+    index: number;
+    message: {
+      role: string;
+      content: string | null;
+      tool_calls?: any[];
+    };
+    finish_reason: string;
+  }>;
+  usage?: {
+    prompt_tokens: number;
+    completion_tokens: number;
+    total_tokens: number;
+  };
+}
+
+export interface InferenceProvider {
+  name: string;
+  chat(request: ChatCompletionRequest): Promise<ChatCompletionResponse>;
+  isConfigured(): boolean;
+}
+
+export interface InferenceConfig {
+  provider: 'openai' | 'anthropic' | 'ollama' | 'custom';
+  apiKey?: string;
+  baseURL?: string;
+  defaultModel?: string;
+  timeout?: number;
+}

package/tsconfig.json

@@ -0,0 +1,18 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "commonjs",
+    "lib": ["ES2020"],
+    "declaration": true,
+    "outDir": "./lib",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "moduleResolution": "node",
+    "resolveJsonModule": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "lib", "__tests__"]
+}