@pioneer-platform/pioneer-inference 1.0.0 → 1.0.1

package/.turbo/turbo-build.log

@@ -0,0 +1 @@
+$ tsc

package/CHANGELOG.md

@@ -0,0 +1,7 @@
+# @pioneer-platform/pioneer-inference
+
+## 1.0.1
+
+### Patch Changes
+
+- Fix workspace dependencies to use published versions for Docker build compatibility

package/README.md

@@ -1,144 +1,217 @@
-# @pioneer-platform/pioneer-inference
+# Pioneer Inference
 
-LLM inference abstraction layer for the Pioneer platform. Provides a unified interface for working with multiple LLM providers (OpenAI, Anthropic, Ollama, etc.).
+OpenAI-compatible inference proxy for the Pioneer platform. This module provides a secure way to expose AI inference capabilities to your apps without exposing API keys.
+
+## Features
+
+- **API Key Protection**: Keep your AI provider API keys secure on the server
+- **System Prompt Injection**: Automatically inject system prompts to guide model behavior
+- **Multi-Provider Support**: Works with OpenAI, OpenRouter, and Venice.ai
+- **OpenAI-Compatible API**: Drop-in replacement for OpenAI client libraries
 
 ## Installation
 
-```bash
-npm install @pioneer-platform/pioneer-inference
+This is a workspace package in the Pioneer monorepo. It's automatically available to other packages via:
+
+```typescript
+import { InferenceService, createInferenceServiceFromEnv } from '@pioneer-platform/pioneer-inference';
 ```
 
-## Usage
+## Configuration
 
-### Basic Usage
+Set the following environment variables:
 
-```typescript
-import { InferenceClient } from '@pioneer-platform/pioneer-inference';
+```bash
+# Provider selection (openai, openrouter, or venice)
+INFERENCE_PROVIDER=openai
 
-const client = new InferenceClient({
-  provider: 'openai',
-  apiKey: process.env.OPENAI_API_KEY,
-});
+# API key for the selected provider
+INFERENCE_API_KEY=your-api-key-here
+# Or use the standard OpenAI key
+OPENAI_API_KEY=your-api-key-here
+
+# Optional: Custom base URL (for self-hosted or proxy endpoints)
+INFERENCE_BASE_URL=https://api.openai.com/v1
 
-// Set system prompt
-client.setSystemPrompt('You are a helpful coding assistant.');
+# Optional: System prompt to inject in all requests
+INFERENCE_SYSTEM_PROMPT="You are a helpful cryptocurrency wallet assistant."
 
-// Send a message
-const response = await client.chat('Help me write a function');
-console.log(response);
+# Optional: Default model to use
+INFERENCE_DEFAULT_MODEL=gpt-4-turbo-preview
 ```
 
-### Point to Custom Endpoint
+## Provider Configuration
 
-```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',
-});
+### OpenAI
+```bash
+INFERENCE_PROVIDER=openai
+INFERENCE_API_KEY=sk-...
+# Default model: gpt-4-turbo-preview
 ```
 
-### Using with Pioneer Server
+### OpenRouter
+```bash
+INFERENCE_PROVIDER=openrouter
+INFERENCE_API_KEY=sk-or-...
+INFERENCE_BASE_URL=https://openrouter.ai/api/v1
+# Default model: anthropic/claude-3-opus
+```
 
-```typescript
-import { InferenceClient } from '@pioneer-platform/pioneer-inference';
+### Venice.ai
+```bash
+INFERENCE_PROVIDER=venice
+INFERENCE_API_KEY=your-venice-key
+INFERENCE_BASE_URL=https://api.venice.ai/api/v1
+# Default model: llama-3.1-405b
+```
 
-// 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',
-});
+## Usage
+
+### REST API Endpoints
+
+The Pioneer server exposes OpenAI-compatible endpoints at `/v1`:
 
-const response = await client.chat('What can you help me with?');
+#### Create Chat Completion
+```bash
+POST http://localhost:9001/v1/chat/completions
+Content-Type: application/json
+
+{
+  "model": "gpt-4-turbo-preview",
+  "messages": [
+    {
+      "role": "user",
+      "content": "What is Bitcoin?"
+    }
+  ],
+  "temperature": 0.7,
+  "max_tokens": 150
+}
 ```
 
-### Full Control with Chat Completions
+#### List Available Models
+```bash
+GET http://localhost:9001/v1/models
+```
+
+#### Get Provider Info
+```bash
+GET http://localhost:9001/v1/provider
+```
+
+Response:
+```json
+{
+  "provider": "openai",
+  "hasSystemPrompt": true,
+  "configured": true
+}
+```
+
+### Using in TypeScript
 
 ```typescript
-const response = await client.chatCompletion({
+import { InferenceService } from '@pioneer-platform/pioneer-inference';
+
+// Create service with custom configuration
+const service = new InferenceService({
+  provider: 'openai',
+  apiKey: 'sk-...',
+  systemPrompt: 'You are a crypto assistant.',
+  defaultModel: 'gpt-4-turbo-preview'
+});
+
+// Create chat completion
+const response = await service.createChatCompletion({
   model: 'gpt-4-turbo-preview',
   messages: [
-    { role: 'system', content: 'You are a helpful assistant.' },
-    { role: 'user', content: 'Hello!' },
+    { role: 'user', content: 'Explain blockchain' }
   ],
   temperature: 0.7,
-  max_tokens: 500,
+  max_tokens: 150
 });
 
 console.log(response.choices[0].message.content);
 ```
 
-### Conversation History Management
+### Using from Browser/Frontend
+
+Your frontend apps can call the Pioneer server endpoints without exposing API keys:
 
 ```typescript
-// Get history
-const history = client.getHistory();
+// Using OpenAI client library with Pioneer server as base URL
+import OpenAI from 'openai';
 
-// Clear history (keep system prompt)
-client.clearHistory(true);
+const client = new OpenAI({
+  apiKey: 'not-needed', // Server handles authentication
+  baseURL: 'http://localhost:9001/v1',
+  dangerouslyAllowBrowser: true // Only because we're proxying
+});
 
-// Clear everything
-client.clearHistory(false);
+const completion = await client.chat.completions.create({
+  model: 'gpt-4-turbo-preview',
+  messages: [
+    { role: 'user', content: 'What is Ethereum?' }
+  ]
+});
 
-// Get message count
-const count = client.getMessageCount();
+console.log(completion.choices[0].message.content);
 ```
 
-## API
-
-### InferenceClient
-
-#### Constructor
+Or using fetch directly:
 
 ```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
+const response = await fetch('http://localhost:9001/v1/chat/completions', {
+  method: 'POST',
+  headers: {
+    'Content-Type': 'application/json'
+  },
+  body: JSON.stringify({
+    model: 'gpt-4-turbo-preview',
+    messages: [
+      { role: 'user', content: 'What is Ethereum?' }
+    ]
+  })
+});
 
-- `chat(message: string, options?: Partial<ChatCompletionRequest>): Promise<string>`
-  - Send a chat message and get a response
+const data = await response.json();
+console.log(data.choices[0].message.content);
+```
 
-- `chatCompletion(request: ChatCompletionRequest): Promise<ChatCompletionResponse>`
-  - Full control over chat completion request
+## System Prompt Injection
 
-- `setSystemPrompt(prompt: string): void`
-  - Set or update the system prompt
+The service automatically injects a system prompt if:
+1. A system prompt is configured via `INFERENCE_SYSTEM_PROMPT` or in the config
+2. The messages array doesn't already contain a system message
 
-- `clearHistory(keepSystemPrompt?: boolean): void`
-  - Clear conversation history
+This ensures consistent model behavior across all requests without requiring clients to specify the system prompt.
 
-- `getHistory(): Message[]`
-  - Get conversation history
+## Security Considerations
 
-- `getMessageCount(): number`
-  - Get message count (excluding system messages)
+- **Never expose your API keys to the frontend** - always use the server proxy
+- The Pioneer server should be configured with appropriate CORS settings
+- Consider adding authentication to the inference endpoints for production use
+- Rate limiting should be implemented to prevent API abuse
 
-- `isConfigured(): boolean`
-  - Check if provider is properly configured
+## API Compatibility
 
-- `getProviderName(): string`
-  - Get the current provider name
+This module implements the OpenAI Chat Completions API specification, making it compatible with:
+- OpenAI's official client libraries
+- Any tool or library that supports OpenAI-compatible APIs
+- LangChain, LlamaIndex, and other AI frameworks
 
-## Supported Providers
+## Development
 
-### OpenAI (Implemented)
-- Native OpenAI API support
-- Custom OpenAI-compatible endpoints (like pioneer-server)
+Build the module:
+```bash
+cd modules/pioneer/pioneer-inference
+bun run build
+```
 
-### Coming Soon
-- Anthropic (Claude)
-- Ollama (local models)
-- Custom providers
+Watch for changes:
+```bash
+bun run build:watch
+```
 
 ## License
 

package/dist/index.d.ts

@@ -0,0 +1,80 @@
+export type InferenceProvider = 'openai' | 'openrouter' | 'venice';
+export interface InferenceConfig {
+    provider: InferenceProvider;
+    apiKey: string;
+    baseURL?: string;
+    systemPrompt?: string;
+    defaultModel?: string;
+}
+export interface ChatMessage {
+    role: 'system' | 'user' | 'assistant';
+    content: string;
+}
+export interface ChatCompletionRequest {
+    model: string;
+    messages: ChatMessage[];
+    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: ChatMessage;
+        finish_reason: string;
+    }>;
+    usage: {
+        prompt_tokens: number;
+        completion_tokens: number;
+        total_tokens: number;
+    };
+}
+export declare class InferenceService {
+    private client;
+    private config;
+    private systemPrompt?;
+    constructor(config: InferenceConfig);
+    /**
+     * Get the appropriate base URL for the provider
+     */
+    private getBaseURL;
+    /**
+     * Get default model for the provider
+     */
+    private getDefaultModel;
+    /**
+     * Create a chat completion
+     * This is the main proxy method that injects system prompts and protects API keys
+     */
+    createChatCompletion(request: ChatCompletionRequest): Promise<ChatCompletionResponse>;
+    /**
+     * Stream chat completion (for real-time responses)
+     */
+    createStreamingChatCompletion(request: ChatCompletionRequest): Promise<any>;
+    /**
+     * List available models
+     */
+    listModels(): Promise<any>;
+    /**
+     * Get provider information
+     */
+    getProviderInfo(): {
+        provider: InferenceProvider;
+        hasSystemPrompt: boolean;
+    };
+    /**
+     * Update system prompt
+     */
+    setSystemPrompt(prompt: string): void;
+}
+/**
+ * Factory function to create inference service from environment variables
+ */
+export declare function createInferenceServiceFromEnv(): InferenceService;
+export default InferenceService;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAeA,MAAM,MAAM,iBAAiB,GAAG,QAAQ,GAAG,YAAY,GAAG,QAAQ,CAAC;AAEnE,MAAM,WAAW,eAAe;IAC5B,QAAQ,EAAE,iBAAiB,CAAC;IAC5B,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,YAAY,CAAC,EAAE,MAAM,CAAC;CACzB;AAED,MAAM,WAAW,WAAW;IACxB,IAAI,EAAE,QAAQ,GAAG,MAAM,GAAG,WAAW,CAAC;IACtC,OAAO,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,qBAAqB;IAClC,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,WAAW,EAAE,CAAC;IACxB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAC;CACtB;AAED,MAAM,WAAW,sBAAsB;IACnC,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,KAAK,CAAC;QACX,KAAK,EAAE,MAAM,CAAC;QACd,OAAO,EAAE,WAAW,CAAC;QACrB,aAAa,EAAE,MAAM,CAAC;KACzB,CAAC,CAAC;IACH,KAAK,EAAE;QACH,aAAa,EAAE,MAAM,CAAC;QACtB,iBAAiB,EAAE,MAAM,CAAC;QAC1B,YAAY,EAAE,MAAM,CAAC;KACxB,CAAC;CACL;AAED,qBAAa,gBAAgB;IACzB,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,MAAM,CAAkB;IAChC,OAAO,CAAC,YAAY,CAAC,CAAS;gBAElB,MAAM,EAAE,eAAe;IAiBnC;;OAEG;IACH,OAAO,CAAC,UAAU;IAiBlB;;OAEG;IACH,OAAO,CAAC,eAAe;IAiBvB;;;OAGG;IACG,oBAAoB,CACtB,OAAO,EAAE,qBAAqB,GAC/B,OAAO,CAAC,sBAAsB,CAAC;IAgClC;;OAEG;IACG,6BAA6B,CAC/B,OAAO,EAAE,qBAAqB,GAC/B,OAAO,CAAC,GAAG,CAAC;IAgCf;;OAEG;IACG,UAAU,IAAI,OAAO,CAAC,GAAG,CAAC;IAYhC;;OAEG;IACH,eAAe,IAAI;QAAE,QAAQ,EAAE,iBAAiB,CAAC;QAAC,eAAe,EAAE,OAAO,CAAA;KAAE;IAO5E;;OAEG;IACH,eAAe,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;CAGxC;AAED;;GAEG;AACH,wBAAgB,6BAA6B,IAAI,gBAAgB,CAoBhE;AAED,eAAe,gBAAgB,CAAC"}

package/dist/index.js

@@ -0,0 +1,184 @@
+"use strict";
+/*
+    Inference Proxy
+
+    Goals:
+    - Match OpenAI's API structure for compatibility
+    - Allow configuring between openai, openrouter, venice.ai
+    - All providers follow the OpenAI API format
+    - Primary purpose: system prompt injection and API key protection
+*/
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InferenceService = void 0;
+exports.createInferenceServiceFromEnv = createInferenceServiceFromEnv;
+const TAG = ' | pioneer-inference | ';
+const log = require('@pioneer-platform/loggerdog')();
+const openai_1 = __importDefault(require("openai"));
+class InferenceService {
+    constructor(config) {
+        const tag = TAG + ' | constructor | ';
+        this.config = config;
+        this.systemPrompt = config.systemPrompt;
+        // Get base URL based on provider
+        const baseURL = this.getBaseURL();
+        log.info(tag, `Initializing ${config.provider} with baseURL: ${baseURL}`);
+        // Initialize OpenAI client (works with all OpenAI-compatible APIs)
+        this.client = new openai_1.default({
+            apiKey: config.apiKey,
+            baseURL,
+        });
+    }
+    /**
+     * Get the appropriate base URL for the provider
+     */
+    getBaseURL() {
+        if (this.config.baseURL) {
+            return this.config.baseURL;
+        }
+        switch (this.config.provider) {
+            case 'openai':
+                return undefined; // Use default OpenAI URL
+            case 'openrouter':
+                return 'https://openrouter.ai/api/v1';
+            case 'venice':
+                return 'https://api.venice.ai/api/v1';
+            default:
+                return undefined;
+        }
+    }
+    /**
+     * Get default model for the provider
+     */
+    getDefaultModel() {
+        if (this.config.defaultModel) {
+            return this.config.defaultModel;
+        }
+        switch (this.config.provider) {
+            case 'openai':
+                return 'gpt-4-turbo-preview';
+            case 'openrouter':
+                return 'anthropic/claude-3-opus';
+            case 'venice':
+                return 'llama-3.1-405b';
+            default:
+                return 'gpt-4-turbo-preview';
+        }
+    }
+    /**
+     * Create a chat completion
+     * This is the main proxy method that injects system prompts and protects API keys
+     */
+    async createChatCompletion(request) {
+        const tag = TAG + ' | createChatCompletion | ';
+        try {
+            // Inject system prompt if configured and not already present
+            const messages = [...request.messages];
+            if (this.systemPrompt && !messages.some(m => m.role === 'system')) {
+                messages.unshift({
+                    role: 'system',
+                    content: this.systemPrompt,
+                });
+            }
+            // Use configured default model if not specified
+            const model = request.model || this.getDefaultModel();
+            log.info(tag, `Creating completion with model: ${model}, messages: ${messages.length}`);
+            // Make the API call
+            const completion = await this.client.chat.completions.create({
+                ...request,
+                model,
+                messages,
+            });
+            return completion;
+        }
+        catch (error) {
+            log.error(tag, 'Error creating chat completion:', error);
+            throw error;
+        }
+    }
+    /**
+     * Stream chat completion (for real-time responses)
+     */
+    async createStreamingChatCompletion(request) {
+        const tag = TAG + ' | createStreamingChatCompletion | ';
+        try {
+            // Inject system prompt if configured
+            const messages = [...request.messages];
+            if (this.systemPrompt && !messages.some(m => m.role === 'system')) {
+                messages.unshift({
+                    role: 'system',
+                    content: this.systemPrompt,
+                });
+            }
+            const model = request.model || this.getDefaultModel();
+            log.info(tag, `Creating streaming completion with model: ${model}`);
+            // Make streaming API call
+            const stream = await this.client.chat.completions.create({
+                ...request,
+                model,
+                messages,
+                stream: true,
+            });
+            return stream;
+        }
+        catch (error) {
+            log.error(tag, 'Error creating streaming chat completion:', error);
+            throw error;
+        }
+    }
+    /**
+     * List available models
+     */
+    async listModels() {
+        const tag = TAG + ' | listModels | ';
+        try {
+            const models = await this.client.models.list();
+            return models;
+        }
+        catch (error) {
+            log.error(tag, 'Error listing models:', error);
+            throw error;
+        }
+    }
+    /**
+     * Get provider information
+     */
+    getProviderInfo() {
+        return {
+            provider: this.config.provider,
+            hasSystemPrompt: !!this.systemPrompt,
+        };
+    }
+    /**
+     * Update system prompt
+     */
+    setSystemPrompt(prompt) {
+        this.systemPrompt = prompt;
+    }
+}
+exports.InferenceService = InferenceService;
+/**
+ * Factory function to create inference service from environment variables
+ */
+function createInferenceServiceFromEnv() {
+    const tag = TAG + ' | createInferenceServiceFromEnv | ';
+    const provider = (process.env.INFERENCE_PROVIDER || 'openai');
+    const apiKey = process.env.INFERENCE_API_KEY || process.env.OPENAI_API_KEY || '';
+    const baseURL = process.env.INFERENCE_BASE_URL;
+    const systemPrompt = process.env.INFERENCE_SYSTEM_PROMPT;
+    const defaultModel = process.env.INFERENCE_DEFAULT_MODEL;
+    if (!apiKey) {
+        log.warn(tag, 'No API key found in environment variables');
+    }
+    return new InferenceService({
+        provider,
+        apiKey,
+        baseURL,
+        systemPrompt,
+        defaultModel,
+    });
+}
+exports.default = InferenceService;
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AAAA;;;;;;;;EAQE;;;;;;AA6NF,sEAoBC;AA/OD,MAAM,GAAG,GAAG,yBAAyB,CAAC;AACtC,MAAM,GAAG,GAAG,OAAO,CAAC,6BAA6B,CAAC,EAAE,CAAC;AAErD,oDAA4B;AA2C5B,MAAa,gBAAgB;IAKzB,YAAY,MAAuB;QAC/B,MAAM,GAAG,GAAG,GAAG,GAAG,mBAAmB,CAAC;QACtC,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;QACrB,IAAI,CAAC,YAAY,GAAG,MAAM,CAAC,YAAY,CAAC;QAExC,iCAAiC;QACjC,MAAM,OAAO,GAAG,IAAI,CAAC,UAAU,EAAE,CAAC;QAElC,GAAG,CAAC,IAAI,CAAC,GAAG,EAAE,gBAAgB,MAAM,CAAC,QAAQ,kBAAkB,OAAO,EAAE,CAAC,CAAC;QAE1E,mEAAmE;QACnE,IAAI,CAAC,MAAM,GAAG,IAAI,gBAAM,CAAC;YACrB,MAAM,EAAE,MAAM,CAAC,MAAM;YACrB,OAAO;SACV,CAAC,CAAC;IACP,CAAC;IAED;;OAEG;IACK,UAAU;QACd,IAAI,IAAI,CAAC,MAAM,CAAC,OAAO,EAAE,CAAC;YACtB,OAAO,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC;QAC/B,CAAC;QAED,QAAQ,IAAI,CAAC,MAAM,CAAC,QAAQ,EAAE,CAAC;YAC3B,KAAK,QAAQ;gBACT,OAAO,SAAS,CAAC,CAAC,yBAAyB;YAC/C,KAAK,YAAY;gBACb,OAAO,8BAA8B,CAAC;YAC1C,KAAK,QAAQ;gBACT,OAAO,8BAA8B,CAAC;YAC1C;gBACI,OAAO,SAAS,CAAC;QACzB,CAAC;IACL,CAAC;IAED;;OAEG;IACK,eAAe;QACnB,IAAI,IAAI,CAAC,MAAM,CAAC,YAAY,EAAE,CAAC;YAC3B,OAAO,IAAI,CAAC,MAAM,CAAC,YAAY,CAAC;QACpC,CAAC;QAED,QAAQ,IAAI,CAAC,MAAM,CAAC,QAAQ,EAAE,CAAC;YAC3B,KAAK,QAAQ;gBACT,OAAO,qBAAqB,CAAC;YACjC,KAAK,YAAY;gBACb,OAAO,yBAAyB,CAAC;YACrC,KAAK,QAAQ;gBACT,OAAO,gBAAgB,CAAC;YAC5B;gBACI,OAAO,qBAAqB,CAAC;QACrC,CAAC;IACL,CAAC;IAED;;;OAGG;IACH,KAAK,CAAC,oBAAoB,CACtB,OAA8B;QAE9B,MAAM,GAAG,GAAG,GAAG,GAAG,4BAA4B,CAAC;QAE/C,IAAI,CAAC;YACD,6DAA6D;YAC7D,MAAM,QAAQ,GAAG,CAAC,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAC;YACvC,IAAI,IAAI,CAAC,YAAY,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,QAAQ,CAAC,EAAE,CAAC;gBAChE,QAAQ,CAAC,OAAO,CAAC;oBACb,IAAI,EAAE,QAAQ;oBACd,OAAO,EAAE,IAAI,CAAC,YAAY;iBAC7B,CAAC,CAAC;YACP,CAAC;YAED,gDAAgD;YAChD,MAAM,KAAK,GAAG,OAAO,CAAC,KAAK,IAAI,IAAI,CAAC,eAAe,EAAE,CAAC;YAEtD,GAAG,CAAC,IAAI,CAAC,GAAG,EAAE,mCAAmC,KAAK,eAAe,QAAQ,CAAC,MAAM,EAAE,CAAC,CAAC;YAExF,oBAAoB;YACpB,MAAM,UAAU,GAAG,MAAM,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,WAAW,CAAC,MAAM,CAAC;gBACzD,GAAG,OAAO;gBACV,KAAK;gBACL,QAAQ;aACX,CAAC,CAAC;YAEH,OAAO,UAAoC,CAAC;QAChD,CAAC;QAAC,OAAO,KAAU,EAAE,CAAC;YAClB,GAAG,CAAC,KAAK,CAAC,GAAG,EAAE,iCAAiC,EAAE,KAAK,CAAC,CAAC;YACzD,MAAM,KAAK,CAAC;QAChB,CAAC;IACL,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,6BAA6B,CAC/B,OAA8B;QAE9B,MAAM,GAAG,GAAG,GAAG,GAAG,qCAAqC,CAAC;QAExD,IAAI,CAAC;YACD,qCAAqC;YACrC,MAAM,QAAQ,GAAG,CAAC,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAC;YACvC,IAAI,IAAI,CAAC,YAAY,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,QAAQ,CAAC,EAAE,CAAC;gBAChE,QAAQ,CAAC,OAAO,CAAC;oBACb,IAAI,EAAE,QAAQ;oBACd,OAAO,EAAE,IAAI,CAAC,YAAY;iBAC7B,CAAC,CAAC;YACP,CAAC;YAED,MAAM,KAAK,GAAG,OAAO,CAAC,KAAK,IAAI,IAAI,CAAC,eAAe,EAAE,CAAC;YAEtD,GAAG,CAAC,IAAI,CAAC,GAAG,EAAE,6CAA6C,KAAK,EAAE,CAAC,CAAC;YAEpE,0BAA0B;YAC1B,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,WAAW,CAAC,MAAM,CAAC;gBACrD,GAAG,OAAO;gBACV,KAAK;gBACL,QAAQ;gBACR,MAAM,EAAE,IAAI;aACf,CAAC,CAAC;YAEH,OAAO,MAAM,CAAC;QAClB,CAAC;QAAC,OAAO,KAAU,EAAE,CAAC;YAClB,GAAG,CAAC,KAAK,CAAC,GAAG,EAAE,2CAA2C,EAAE,KAAK,CAAC,CAAC;YACnE,MAAM,KAAK,CAAC;QAChB,CAAC;IACL,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,UAAU;QACZ,MAAM,GAAG,GAAG,GAAG,GAAG,kBAAkB,CAAC;QAErC,IAAI,CAAC;YACD,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,CAAC;YAC/C,OAAO,MAAM,CAAC;QAClB,CAAC;QAAC,OAAO,KAAU,EAAE,CAAC;YAClB,GAAG,CAAC,KAAK,CAAC,GAAG,EAAE,uBAAuB,EAAE,KAAK,CAAC,CAAC;YAC/C,MAAM,KAAK,CAAC;QAChB,CAAC;IACL,CAAC;IAED;;OAEG;IACH,eAAe;QACX,OAAO;YACH,QAAQ,EAAE,IAAI,CAAC,MAAM,CAAC,QAAQ;YAC9B,eAAe,EAAE,CAAC,CAAC,IAAI,CAAC,YAAY;SACvC,CAAC;IACN,CAAC;IAED;;OAEG;IACH,eAAe,CAAC,MAAc;QAC1B,IAAI,CAAC,YAAY,GAAG,MAAM,CAAC;IAC/B,CAAC;CACJ;AAxKD,4CAwKC;AAED;;GAEG;AACH,SAAgB,6BAA6B;IACzC,MAAM,GAAG,GAAG,GAAG,GAAG,qCAAqC,CAAC;IAExD,MAAM,QAAQ,GAAG,CAAC,OAAO,CAAC,GAAG,CAAC,kBAAkB,IAAI,QAAQ,CAAsB,CAAC;IACnF,MAAM,MAAM,GAAG,OAAO,CAAC,GAAG,CAAC,iBAAiB,IAAI,OAAO,CAAC,GAAG,CAAC,cAAc,IAAI,EAAE,CAAC;IACjF,MAAM,OAAO,GAAG,OAAO,CAAC,GAAG,CAAC,kBAAkB,CAAC;IAC/C,MAAM,YAAY,GAAG,OAAO,CAAC,GAAG,CAAC,uBAAuB,CAAC;IACzD,MAAM,YAAY,GAAG,OAAO,CAAC,GAAG,CAAC,uBAAuB,CAAC;IAEzD,IAAI,CAAC,MAAM,EAAE,CAAC;QACV,GAAG,CAAC,IAAI,CAAC,GAAG,EAAE,2CAA2C,CAAC,CAAC;IAC/D,CAAC;IAED,OAAO,IAAI,gBAAgB,CAAC;QACxB,QAAQ;QACR,MAAM;QACN,OAAO;QACP,YAAY;QACZ,YAAY;KACf,CAAC,CAAC;AACP,CAAC;AAED,kBAAe,gBAAgB,CAAC"}

package/package.json

@@ -1,36 +1,29 @@
 {
   "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"
-    }
-  },
+  "version": "1.0.1",
+  "description": "OpenAI-compatible inference proxy for Pioneer platform",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
   "scripts": {
-    "build": "tsc -p .",
-    "build:watch": "tsc -p . --watch",
-    "test": "echo \"Error: no test specified\" && exit 1",
-    "prepublish": "npm run build"
+    "build": "tsc",
+    "build:watch": "tsc --watch",
+    "clean": "rm -rf dist node_modules"
   },
   "keywords": [
-    "ai",
-    "llm",
-    "openai",
+    "pioneer",
     "inference",
-    "pioneer"
+    "openai",
+    "ai",
+    "llm"
   ],
-  "author": "Pioneer Platform",
-  "license": "MIT",
+  "author": "",
+  "license": "ISC",
   "dependencies": {
+    "@pioneer-platform/loggerdog": "^8.0.0",
     "openai": "^4.26.0"
   },
-  "peerDependencies": {},
   "devDependencies": {
-    "@types/node": "^20.11.16",
-    "typescript": "^5.3.3"
+    "@types/node": "^22.14.1",
+    "typescript": "^5.8.3"
   }
 }

package/src/index.ts

@@ -1,30 +1,252 @@
+/*
+    Inference Proxy
+
+    Goals:
+    - Match OpenAI's API structure for compatibility
+    - Allow configuring between openai, openrouter, venice.ai
+    - All providers follow the OpenAI API format
+    - Primary purpose: system prompt injection and API key protection
+*/
+
+const TAG = ' | pioneer-inference | ';
+const log = require('@pioneer-platform/loggerdog')();
+
+import OpenAI from 'openai';
+
+export type InferenceProvider = 'openai' | 'openrouter' | 'venice';
+
+export interface InferenceConfig {
+    provider: InferenceProvider;
+    apiKey: string;
+    baseURL?: string;
+    systemPrompt?: string;
+    defaultModel?: string;
+}
+
+export interface ChatMessage {
+    role: 'system' | 'user' | 'assistant';
+    content: string;
+}
+
+export interface ChatCompletionRequest {
+    model: string;
+    messages: ChatMessage[];
+    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: ChatMessage;
+        finish_reason: string;
+    }>;
+    usage: {
+        prompt_tokens: number;
+        completion_tokens: number;
+        total_tokens: number;
+    };
+}
+
+export class InferenceService {
+    private client: OpenAI;
+    private config: InferenceConfig;
+    private systemPrompt?: string;
+
+    constructor(config: InferenceConfig) {
+        const tag = TAG + ' | constructor | ';
+        this.config = config;
+        this.systemPrompt = config.systemPrompt;
+
+        // Get base URL based on provider
+        const baseURL = this.getBaseURL();
+
+        log.info(tag, `Initializing ${config.provider} with baseURL: ${baseURL}`);
+
+        // Initialize OpenAI client (works with all OpenAI-compatible APIs)
+        this.client = new OpenAI({
+            apiKey: config.apiKey,
+            baseURL,
+        });
+    }
+
+    /**
+     * Get the appropriate base URL for the provider
+     */
+    private getBaseURL(): string | undefined {
+        if (this.config.baseURL) {
+            return this.config.baseURL;
+        }
+
+        switch (this.config.provider) {
+            case 'openai':
+                return undefined; // Use default OpenAI URL
+            case 'openrouter':
+                return 'https://openrouter.ai/api/v1';
+            case 'venice':
+                return 'https://api.venice.ai/api/v1';
+            default:
+                return undefined;
+        }
+    }
+
+    /**
+     * Get default model for the provider
+     */
+    private getDefaultModel(): string {
+        if (this.config.defaultModel) {
+            return this.config.defaultModel;
+        }
+
+        switch (this.config.provider) {
+            case 'openai':
+                return 'gpt-4-turbo-preview';
+            case 'openrouter':
+                return 'anthropic/claude-3-opus';
+            case 'venice':
+                return 'llama-3.1-405b';
+            default:
+                return 'gpt-4-turbo-preview';
+        }
+    }
+
+    /**
+     * Create a chat completion
+     * This is the main proxy method that injects system prompts and protects API keys
+     */
+    async createChatCompletion(
+        request: ChatCompletionRequest
+    ): Promise<ChatCompletionResponse> {
+        const tag = TAG + ' | createChatCompletion | ';
+
+        try {
+            // Inject system prompt if configured and not already present
+            const messages = [...request.messages];
+            if (this.systemPrompt && !messages.some(m => m.role === 'system')) {
+                messages.unshift({
+                    role: 'system',
+                    content: this.systemPrompt,
+                });
+            }
+
+            // Use configured default model if not specified
+            const model = request.model || this.getDefaultModel();
+
+            log.info(tag, `Creating completion with model: ${model}, messages: ${messages.length}`);
+
+            // Make the API call
+            const completion = await this.client.chat.completions.create({
+                ...request,
+                model,
+                messages,
+            });
+
+            return completion as ChatCompletionResponse;
+        } catch (error: any) {
+            log.error(tag, 'Error creating chat completion:', error);
+            throw error;
+        }
+    }
+
+    /**
+     * Stream chat completion (for real-time responses)
+     */
+    async createStreamingChatCompletion(
+        request: ChatCompletionRequest
+    ): Promise<any> {
+        const tag = TAG + ' | createStreamingChatCompletion | ';
+
+        try {
+            // Inject system prompt if configured
+            const messages = [...request.messages];
+            if (this.systemPrompt && !messages.some(m => m.role === 'system')) {
+                messages.unshift({
+                    role: 'system',
+                    content: this.systemPrompt,
+                });
+            }
+
+            const model = request.model || this.getDefaultModel();
+
+            log.info(tag, `Creating streaming completion with model: ${model}`);
+
+            // Make streaming API call
+            const stream = await this.client.chat.completions.create({
+                ...request,
+                model,
+                messages,
+                stream: true,
+            });
+
+            return stream;
+        } catch (error: any) {
+            log.error(tag, 'Error creating streaming chat completion:', error);
+            throw error;
+        }
+    }
+
+    /**
+     * List available models
+     */
+    async listModels(): Promise<any> {
+        const tag = TAG + ' | listModels | ';
+
+        try {
+            const models = await this.client.models.list();
+            return models;
+        } catch (error: any) {
+            log.error(tag, 'Error listing models:', error);
+            throw error;
+        }
+    }
+
+    /**
+     * Get provider information
+     */
+    getProviderInfo(): { provider: InferenceProvider; hasSystemPrompt: boolean } {
+        return {
+            provider: this.config.provider,
+            hasSystemPrompt: !!this.systemPrompt,
+        };
+    }
+
+    /**
+     * Update system prompt
+     */
+    setSystemPrompt(prompt: string): void {
+        this.systemPrompt = prompt;
+    }
+}
+
 /**
- * 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);
- * ```
+ * Factory function to create inference service from environment variables
  */
+export function createInferenceServiceFromEnv(): InferenceService {
+    const tag = TAG + ' | createInferenceServiceFromEnv | ';
+
+    const provider = (process.env.INFERENCE_PROVIDER || 'openai') as InferenceProvider;
+    const apiKey = process.env.INFERENCE_API_KEY || process.env.OPENAI_API_KEY || '';
+    const baseURL = process.env.INFERENCE_BASE_URL;
+    const systemPrompt = process.env.INFERENCE_SYSTEM_PROMPT;
+    const defaultModel = process.env.INFERENCE_DEFAULT_MODEL;
+
+    if (!apiKey) {
+        log.warn(tag, 'No API key found in environment variables');
+    }
 
-export { InferenceClient } from './inference';
-export { OpenAIProvider } from './providers/openai';
+    return new InferenceService({
+        provider,
+        apiKey,
+        baseURL,
+        systemPrompt,
+        defaultModel,
+    });
+}
 
-export type {
-  Message,
-  ChatCompletionRequest,
-  ChatCompletionResponse,
-  InferenceProvider,
-  InferenceConfig,
-} from './types';
+export default InferenceService;

package/tsconfig.json

@@ -3,16 +3,18 @@
     "target": "ES2020",
     "module": "commonjs",
     "lib": ["ES2020"],
-    "declaration": true,
-    "outDir": "./lib",
+    "outDir": "./dist",
     "rootDir": "./src",
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
     "strict": true,
     "esModuleInterop": true,
     "skipLibCheck": true,
     "forceConsistentCasingInFileNames": true,
-    "moduleResolution": "node",
-    "resolveJsonModule": true
+    "resolveJsonModule": true,
+    "moduleResolution": "node"
   },
   "include": ["src/**/*"],
-  "exclude": ["node_modules", "lib", "__tests__"]
+  "exclude": ["node_modules", "dist"]
 }

package/src/inference.ts

@@ -1,138 +0,0 @@
-/**
- * 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

@@ -1,69 +0,0 @@
-/**
- * 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

@@ -1,55 +0,0 @@
-/**
- * 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;
-}