@webwaka/core 1.3.0

package/package.json

@@ -0,0 +1,99 @@
+{
+  "name": "@webwaka/core",
+  "version": "1.3.0",
+  "description": "WebWaka OS v4 — Shared platform primitives: auth, RBAC, CORS, rate-limiting, event bus types, and billing utilities.",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    },
+    "./auth": {
+      "import": "./dist/core/auth/index.js",
+      "types": "./dist/core/auth/index.d.ts"
+    },
+    "./rbac": {
+      "import": "./dist/core/rbac/index.js",
+      "types": "./dist/core/rbac/index.d.ts"
+    },
+    "./billing": {
+      "import": "./dist/core/billing/index.js",
+      "types": "./dist/core/billing/index.d.ts"
+    },
+    "./logger": {
+      "import": "./dist/core/logger/index.js",
+      "types": "./dist/core/logger/index.d.ts"
+    },
+    "./events": {
+      "import": "./dist/core/events/index.js",
+      "types": "./dist/core/events/index.d.ts"
+    },
+    "./ai": {
+      "import": "./dist/core/ai/AIEngine.js",
+      "types": "./dist/core/ai/AIEngine.d.ts"
+    },
+    "./notifications": {
+      "import": "./dist/core/notifications/index.js",
+      "types": "./dist/core/notifications/index.d.ts"
+    },
+    "./kyc": {
+      "import": "./dist/core/kyc/index.js",
+      "types": "./dist/core/kyc/index.d.ts"
+    },
+    "./geolocation": {
+      "import": "./dist/core/geolocation/index.js",
+      "types": "./dist/core/geolocation/index.d.ts"
+    },
+    "./document": {
+      "import": "./dist/core/document/index.js",
+      "types": "./dist/core/document/index.d.ts"
+    },
+    "./chat": {
+      "import": "./dist/core/chat/index.js",
+      "types": "./dist/core/chat/index.d.ts"
+    },
+    "./booking": {
+      "import": "./dist/core/booking/index.js",
+      "types": "./dist/core/booking/index.d.ts"
+    }
+  },
+  "peerDependencies": {
+    "hono": ">=4.0.0"
+  },
+  "devDependencies": {
+    "@cloudflare/workers-types": "^4.20260317.1",
+    "@vitest/coverage-v8": "^1.6.1",
+    "hono": "^4.12.9",
+    "typescript": "^5.9.3",
+    "vitest": "^1.6.1"
+  },
+  "files": [
+    "dist",
+    "src",
+    "CHANGELOG.md"
+  ],
+  "keywords": [
+    "webwaka",
+    "cloudflare-workers",
+    "auth",
+    "jwt",
+    "rbac",
+    "hono",
+    "nigeria",
+    "africa",
+    "saas"
+  ],
+  "license": "UNLICENSED",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/WebWakaDOS/webwaka-core.git"
+  },
+  "scripts": {
+    "build": "tsc",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "lint": "tsc --noEmit"
+  }
+}

package/src/ai.test.ts

@@ -0,0 +1,146 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { OpenRouterClient, createAiClient } from './ai';
+
+const mockFetch = vi.fn();
+vi.stubGlobal('fetch', mockFetch);
+
+beforeEach(() => {
+  mockFetch.mockReset();
+});
+
+const client = new OpenRouterClient('or-test-key');
+
+describe('OpenRouterClient.complete', () => {
+  it('returns content on successful completion', async () => {
+    mockFetch.mockResolvedValueOnce({
+      ok: true,
+      json: () => Promise.resolve({
+        choices: [{ message: { content: 'Hello from AI' } }],
+        model: 'openai/gpt-4o-mini',
+        usage: { total_tokens: 42 },
+      }),
+    });
+    const result = await client.complete({
+      messages: [{ role: 'user', content: 'Say hello' }],
+    });
+    expect(result.content).toBe('Hello from AI');
+    expect(result.tokensUsed).toBe(42);
+    expect(result.model).toBe('openai/gpt-4o-mini');
+    expect(result.error).toBeUndefined();
+  });
+
+  it('uses custom model when provided', async () => {
+    mockFetch.mockResolvedValueOnce({
+      ok: true,
+      json: () => Promise.resolve({
+        choices: [{ message: { content: 'Custom model response' } }],
+        model: 'anthropic/claude-3-haiku',
+        usage: { total_tokens: 10 },
+      }),
+    });
+    const result = await client.complete({
+      model: 'anthropic/claude-3-haiku',
+      messages: [{ role: 'user', content: 'Hi' }],
+    });
+    const body = JSON.parse(mockFetch.mock.calls[0][1].body);
+    expect(body.model).toBe('anthropic/claude-3-haiku');
+    expect(result.content).toBe('Custom model response');
+  });
+
+  it('includes maxTokens and temperature when provided', async () => {
+    mockFetch.mockResolvedValueOnce({
+      ok: true,
+      json: () => Promise.resolve({
+        choices: [{ message: { content: 'ok' } }],
+        model: 'openai/gpt-4o-mini',
+        usage: { total_tokens: 5 },
+      }),
+    });
+    await client.complete({
+      messages: [{ role: 'user', content: 'test' }],
+      maxTokens: 100,
+      temperature: 0.7,
+    });
+    const body = JSON.parse(mockFetch.mock.calls[0][1].body);
+    expect(body.max_tokens).toBe(100);
+    expect(body.temperature).toBe(0.7);
+  });
+
+  it('does not include maxTokens/temperature when not provided', async () => {
+    mockFetch.mockResolvedValueOnce({
+      ok: true,
+      json: () => Promise.resolve({
+        choices: [{ message: { content: 'ok' } }],
+        model: 'openai/gpt-4o-mini',
+        usage: { total_tokens: 5 },
+      }),
+    });
+    await client.complete({
+      messages: [{ role: 'user', content: 'test' }],
+    });
+    const body = JSON.parse(mockFetch.mock.calls[0][1].body);
+    expect(body.max_tokens).toBeUndefined();
+    expect(body.temperature).toBeUndefined();
+  });
+
+  it('returns error when response is not ok', async () => {
+    mockFetch.mockResolvedValueOnce({
+      ok: false,
+      json: () => Promise.resolve({ error: { message: 'Rate limit exceeded' } }),
+    });
+    const result = await client.complete({
+      messages: [{ role: 'user', content: 'test' }],
+    });
+    expect(result.content).toBe('');
+    expect(result.tokensUsed).toBe(0);
+    expect(result.error).toBe('Rate limit exceeded');
+  });
+
+  it('returns fallback error message when error.message is missing', async () => {
+    mockFetch.mockResolvedValueOnce({
+      ok: false,
+      json: () => Promise.resolve({}),
+    });
+    const result = await client.complete({
+      messages: [{ role: 'user', content: 'test' }],
+    });
+    expect(result.error).toBe('OpenRouter request failed');
+  });
+
+  it('returns error when fetch throws', async () => {
+    mockFetch.mockRejectedValueOnce(new Error('Network failure'));
+    const result = await client.complete({
+      messages: [{ role: 'user', content: 'test' }],
+    });
+    expect(result.success).toBeUndefined();
+    expect(result.error).toBe('Network failure');
+    expect(result.content).toBe('');
+  });
+
+  it('returns empty content when choices is missing', async () => {
+    mockFetch.mockResolvedValueOnce({
+      ok: true,
+      json: () => Promise.resolve({
+        choices: [],
+        model: 'openai/gpt-4o-mini',
+        usage: { total_tokens: 0 },
+      }),
+    });
+    const result = await client.complete({
+      messages: [{ role: 'user', content: 'test' }],
+    });
+    expect(result.content).toBe('');
+  });
+});
+
+describe('createAiClient', () => {
+  it('returns an OpenRouterClient instance', () => {
+    const c = createAiClient('or-key-123');
+    expect(c).toBeInstanceOf(OpenRouterClient);
+  });
+
+  it('accepts custom default model', () => {
+    const c = createAiClient('or-key-123', 'anthropic/claude-3-haiku');
+    expect(c).toBeInstanceOf(OpenRouterClient);
+  });
+});

package/src/ai.ts

@@ -0,0 +1,75 @@
+export interface AiMessage {
+  role: 'system' | 'user' | 'assistant';
+  content: string;
+}
+
+export interface AiCompletionOptions {
+  model?: string;
+  messages: AiMessage[];
+  maxTokens?: number;
+  temperature?: number;
+}
+
+export interface AiCompletionResult {
+  content: string;
+  model: string;
+  tokensUsed: number;
+  error?: string;
+}
+
+export class OpenRouterClient {
+  private apiKey: string;
+  private defaultModel: string;
+  private baseUrl = 'https://openrouter.ai/api/v1';
+
+  constructor(apiKey: string, defaultModel = 'openai/gpt-4o-mini') {
+    this.apiKey = apiKey;
+    this.defaultModel = defaultModel;
+  }
+
+  async complete(opts: AiCompletionOptions): Promise<AiCompletionResult> {
+    const model = opts.model ?? this.defaultModel;
+
+    try {
+      const body: Record<string, unknown> = {
+        model,
+        messages: opts.messages,
+      };
+      if (opts.maxTokens !== undefined) body.max_tokens = opts.maxTokens;
+      if (opts.temperature !== undefined) body.temperature = opts.temperature;
+
+      const res = await fetch(`${this.baseUrl}/chat/completions`, {
+        method: 'POST',
+        headers: {
+          Authorization: `Bearer ${this.apiKey}`,
+          'Content-Type': 'application/json',
+          'HTTP-Referer': 'https://webwaka.com',
+          'X-Title': 'WebWaka Commerce',
+        },
+        body: JSON.stringify(body),
+      });
+
+      const data = (await res.json()) as any;
+      if (!res.ok) {
+        return {
+          content: '',
+          model,
+          tokensUsed: 0,
+          error: data?.error?.message ?? 'OpenRouter request failed',
+        };
+      }
+
+      return {
+        content: data.choices?.[0]?.message?.content ?? '',
+        model: data.model ?? model,
+        tokensUsed: data.usage?.total_tokens ?? 0,
+      };
+    } catch (err: any) {
+      return { content: '', model, tokensUsed: 0, error: err?.message };
+    }
+  }
+}
+
+export function createAiClient(apiKey: string, defaultModel?: string): OpenRouterClient {
+  return new OpenRouterClient(apiKey, defaultModel);
+}