@lastbrain/ai-ui-core 1.0.3

package/README.md

@@ -0,0 +1,135 @@
+# @lastbrain/ai-ui-core
+
+Framework-agnostic core library for LastBrain AI UI Kit.
+
+## Features
+
+- HTTP client with retry logic and authentication
+- TypeScript types for AI models, responses, and status
+- Error normalization and handling
+- Response parsing utilities
+
+## Installation
+
+```bash
+npm install @lastbrain/ai-ui-core @lastbrain/ai-ui-react
+# or
+pnpm add @lastbrain/ai-ui-core @lastbrain/ai-ui-react
+```
+
+## 🔐 Secure Integration Guide
+
+**⚠️ NEVER expose your API key in client code!**
+
+### Step 1: Add your LastBrain API key to `.env.local`
+
+```bash
+LB_API_KEY=lb_your_api_key_here
+LB_BASE_URL=https://ai.lastbrain.io  # Optional, defaults to this
+```
+
+### Step 2: Create a secure API proxy route
+
+**For Next.js App Router** - Create `app/api/lastbrain/[...path]/route.ts`:
+
+```typescript
+export { GET, POST } from "@lastbrain/ai-ui-core/route-handlers/nextjs/gateway";
+```
+
+That's it! The package handles all the proxying securely to `https://ai.lastbrain.io/api/public/v1/*`.
+
+### Step 3: Use the React components
+
+```tsx
+"use client";
+import { AiProvider, AiTextarea } from "@lastbrain/ai-ui-react";
+
+export default function MyPage() {
+  return (
+    <AiProvider baseUrl="/api/lastbrain">
+      <div className="p-6 space-y-4">
+        <h1 className="text-xl font-bold">AI UI Demo</h1>
+
+        <AiTextarea
+          placeholder="Describe what you want to generate..."
+          onValue={(content) => console.log("AI response:", content)}
+        />
+      </div>
+    </AiProvider>
+  );
+}
+```
+
+## Complete Example
+
+```bash
+# 1. Install packages
+pnpm add @lastbrain/ai-ui-core @lastbrain/ai-ui-react
+
+# 2. Add to .env.local
+echo "LB_API_KEY=lb_your_key" >> .env.local
+
+# 3. Create route file
+mkdir -p app/api/lastbrain/\[...path\]
+cat > app/api/lastbrain/\[...path\]/route.ts << 'EOF'
+export { GET, POST } from "@lastbrain/ai-ui-core/route-handlers/nextjs/gateway";
+EOF
+
+# 4. Use in your components (see Step 3 above)
+```
+
+## Architecture
+
+```
+Your App → /api/lastbrain → Gateway (with LB_API_KEY) → https://ai.lastbrain.io/api/public/v1
+```
+
+The gateway automatically:
+
+- Adds your API key in Authorization header
+- Proxies all requests to LastBrain API
+- Keeps your API key secure server-side
+
+## Direct Usage (Advanced)
+
+For custom implementations without React components:
+
+```typescript
+import { createClient, ErrorCode } from "@lastbrain/ai-ui-core";
+
+// ⚠️ Only use this server-side!
+const client = createClient({
+  baseUrl: "https://api.lastbrain.io",
+  apiKeyId: "lb_your_api_key",
+});
+
+// Get models
+const models = await client.getModels();
+
+// Generate text
+const result = await client.generateText({
+  model: "openai/gpt-4o-mini",
+  prompt: "Write a story",
+});
+
+// Get status
+const status = await client.getStatus();
+```
+
+## Security Best Practices
+
+✅ **DO:**
+
+- Store API keys in environment variables (`.env.local`)
+- Create server-side proxy routes
+- Use `baseUrl="/api/lastbrain"` in `AiProvider`
+
+❌ **DON'T:**
+
+- Hardcode API keys in client components
+- Pass `apiKeyId` directly in browser code
+- Expose `.env.local` in version control
+
+## API Reference
+
+See the [full documentation](https://docs.lastbrain.com/ai-ui-kit/core) for detailed API reference.

package/dist/client/createClient.d.ts

@@ -0,0 +1,9 @@
+import type { ClientConfig, ModelRef, AiTextRequest, AiTextResponse, AiImageRequest, AiImageResponse, AiEmbedRequest, AiEmbedResponse, AiStatus } from "../types";
+export declare function createClient(config: ClientConfig): {
+    getModels: () => Promise<ModelRef[]>;
+    generateText: (req: AiTextRequest) => Promise<AiTextResponse>;
+    generateImage: (req: AiImageRequest) => Promise<AiImageResponse>;
+    embed: (req: AiEmbedRequest) => Promise<AiEmbedResponse>;
+    getStatus: () => Promise<AiStatus>;
+};
+//# sourceMappingURL=createClient.d.ts.map

package/dist/client/createClient.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createClient.d.ts","sourceRoot":"","sources":["../../src/client/createClient.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,YAAY,EACZ,QAAQ,EACR,aAAa,EACb,cAAc,EACd,cAAc,EACd,eAAe,EACf,cAAc,EACd,eAAe,EACf,QAAQ,EACT,MAAM,UAAU,CAAC;AA6DlB,wBAAgB,YAAY,CAAC,MAAM,EAAE,YAAY;qBAsBnB,OAAO,CAAC,QAAQ,EAAE,CAAC;wBAmCd,aAAa,KAAG,OAAO,CAAC,cAAc,CAAC;yBAmCtC,cAAc,KAAG,OAAO,CAAC,eAAe,CAAC;iBAmCjD,cAAc,KAAG,OAAO,CAAC,eAAe,CAAC;qBAkBvC,OAAO,CAAC,QAAQ,CAAC;EAwB9C"}

package/dist/client/createClient.js

@@ -0,0 +1,179 @@
+import { normalizeError } from "../errors/normalizeError";
+const DEFAULT_TIMEOUT = 60000;
+const DEFAULT_RETRIES = 3;
+const INITIAL_RETRY_DELAY = 1000;
+async function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function fetchWithRetry(url, options, retryConfig) {
+    let lastError;
+    for (let attempt = 0; attempt <= retryConfig.retries; attempt++) {
+        try {
+            const response = await fetch(url, options);
+            if (!response.ok) {
+                const errorData = await response.json().catch(() => ({}));
+                const error = new Error(errorData.message || `HTTP ${response.status}`);
+                error.status = response.status;
+                error.response = { status: response.status };
+                throw error;
+            }
+            return await response.json();
+        }
+        catch (error) {
+            lastError = error;
+            const isRetryable = error.name === "AbortError" ||
+                error.code === "ECONNREFUSED" ||
+                error.code === "ENOTFOUND" ||
+                error.message?.includes("fetch failed") ||
+                (error.status && error.status >= 500);
+            if (isRetryable && attempt < retryConfig.retries) {
+                const delay = retryConfig.delay * Math.pow(2, attempt);
+                await sleep(delay);
+                continue;
+            }
+            throw error;
+        }
+    }
+    throw lastError;
+}
+export function createClient(config) {
+    const timeout = config.timeout ?? DEFAULT_TIMEOUT;
+    const retries = config.retries ?? DEFAULT_RETRIES;
+    function createHeaders() {
+        const headers = {
+            "Content-Type": "application/json",
+        };
+        console.log("[APIKEY] config.apiKeyId:", config.apiKeyId);
+        if (config.apiKeyId) {
+            headers.Authorization = `Bearer ${config.apiKeyId}`;
+        }
+        return headers;
+    }
+    function createAbortSignal() {
+        const controller = new AbortController();
+        setTimeout(() => controller.abort(), timeout);
+        return controller.signal;
+    }
+    async function getModels() {
+        try {
+            const url = `${config.baseUrl}/provider`;
+            const response = await fetchWithRetry(url, {
+                method: "GET",
+                headers: createHeaders(),
+                signal: createAbortSignal(),
+            }, { retries, delay: INITIAL_RETRY_DELAY });
+            // Transform response: extract all models from providers array
+            if (response.providers && Array.isArray(response.providers)) {
+                const allModels = [];
+                for (const provider of response.providers) {
+                    if (provider.models && Array.isArray(provider.models)) {
+                        allModels.push(...provider.models);
+                    }
+                }
+                return allModels;
+            }
+            // Fallback: if response is already a flat array
+            if (Array.isArray(response)) {
+                return response;
+            }
+            return [];
+        }
+        catch (error) {
+            throw normalizeError(error);
+        }
+    }
+    async function generateText(req) {
+        try {
+            const url = `${config.baseUrl}/text-ai`;
+            const response = await fetchWithRetry(url, {
+                method: "POST",
+                headers: createHeaders(),
+                body: JSON.stringify(req),
+                signal: createAbortSignal(),
+            }, { retries, delay: INITIAL_RETRY_DELAY });
+            // Track prompt usage if promptId is provided
+            if (req.promptId) {
+                try {
+                    await fetch(`${config.baseUrl}/track-usage`, {
+                        method: "POST",
+                        headers: createHeaders(),
+                        body: JSON.stringify({ promptId: req.promptId }),
+                    }).catch(() => {
+                        // Silently fail - don't block the response
+                    });
+                }
+                catch (_error) {
+                    // Ignore tracking errors
+                }
+            }
+            return response;
+        }
+        catch (error) {
+            throw normalizeError(error);
+        }
+    }
+    async function generateImage(req) {
+        try {
+            const url = `${config.baseUrl}/image-ai`;
+            const response = await fetchWithRetry(url, {
+                method: "POST",
+                headers: createHeaders(),
+                body: JSON.stringify(req),
+                signal: createAbortSignal(),
+            }, { retries, delay: INITIAL_RETRY_DELAY });
+            // Track prompt usage if promptId is provided
+            if (req.promptId) {
+                try {
+                    await fetch(`${config.baseUrl}/track-usage`, {
+                        method: "POST",
+                        headers: createHeaders(),
+                        body: JSON.stringify({ promptId: req.promptId }),
+                    }).catch(() => {
+                        // Silently fail - don't block the response
+                    });
+                }
+                catch (error) {
+                    // Ignore tracking errors
+                }
+            }
+            return response;
+        }
+        catch (error) {
+            throw normalizeError(error);
+        }
+    }
+    async function embed(req) {
+        try {
+            const url = `${config.baseUrl}/ai/embed`;
+            return await fetchWithRetry(url, {
+                method: "POST",
+                headers: createHeaders(),
+                body: JSON.stringify(req),
+                signal: createAbortSignal(),
+            }, { retries, delay: INITIAL_RETRY_DELAY });
+        }
+        catch (error) {
+            throw normalizeError(error);
+        }
+    }
+    async function getStatus() {
+        try {
+            const url = `${config.baseUrl}/status`;
+            return await fetchWithRetry(url, {
+                method: "GET",
+                headers: createHeaders(),
+                signal: createAbortSignal(),
+            }, { retries, delay: INITIAL_RETRY_DELAY });
+        }
+        catch (error) {
+            throw normalizeError(error);
+        }
+    }
+    return {
+        getModels,
+        generateText,
+        generateImage,
+        embed,
+        getStatus,
+    };
+}

package/dist/errors/errorCodes.d.ts

@@ -0,0 +1,13 @@
+export declare enum ErrorCode {
+    NO_API_KEY = "NO_API_KEY",
+    MODEL_DISABLED = "MODEL_DISABLED",
+    PRICING_UNAVAILABLE = "PRICING_UNAVAILABLE",
+    INSUFFICIENT_TOKENS = "INSUFFICIENT_TOKENS",
+    PROVIDER_DOWN = "PROVIDER_DOWN",
+    BAD_REQUEST = "BAD_REQUEST",
+    UNAUTHORIZED = "UNAUTHORIZED",
+    NETWORK_ERROR = "NETWORK_ERROR",
+    TIMEOUT = "TIMEOUT",
+    UNKNOWN = "UNKNOWN"
+}
+//# sourceMappingURL=errorCodes.d.ts.map

package/dist/errors/errorCodes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errorCodes.d.ts","sourceRoot":"","sources":["../../src/errors/errorCodes.ts"],"names":[],"mappings":"AAAA,oBAAY,SAAS;IACnB,UAAU,eAAe;IACzB,cAAc,mBAAmB;IACjC,mBAAmB,wBAAwB;IAC3C,mBAAmB,wBAAwB;IAC3C,aAAa,kBAAkB;IAC/B,WAAW,gBAAgB;IAC3B,YAAY,iBAAiB;IAC7B,aAAa,kBAAkB;IAC/B,OAAO,YAAY;IACnB,OAAO,YAAY;CACpB"}

package/dist/errors/errorCodes.js

@@ -0,0 +1,13 @@
+export var ErrorCode;
+(function (ErrorCode) {
+    ErrorCode["NO_API_KEY"] = "NO_API_KEY";
+    ErrorCode["MODEL_DISABLED"] = "MODEL_DISABLED";
+    ErrorCode["PRICING_UNAVAILABLE"] = "PRICING_UNAVAILABLE";
+    ErrorCode["INSUFFICIENT_TOKENS"] = "INSUFFICIENT_TOKENS";
+    ErrorCode["PROVIDER_DOWN"] = "PROVIDER_DOWN";
+    ErrorCode["BAD_REQUEST"] = "BAD_REQUEST";
+    ErrorCode["UNAUTHORIZED"] = "UNAUTHORIZED";
+    ErrorCode["NETWORK_ERROR"] = "NETWORK_ERROR";
+    ErrorCode["TIMEOUT"] = "TIMEOUT";
+    ErrorCode["UNKNOWN"] = "UNKNOWN";
+})(ErrorCode || (ErrorCode = {}));

package/dist/errors/normalizeError.d.ts

@@ -0,0 +1,8 @@
+import { ErrorCode } from "./errorCodes";
+export interface NormalizedError {
+    code: ErrorCode;
+    message: string;
+    status?: number;
+}
+export declare function normalizeError(error: any): NormalizedError;
+//# sourceMappingURL=normalizeError.d.ts.map

package/dist/errors/normalizeError.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"normalizeError.d.ts","sourceRoot":"","sources":["../../src/errors/normalizeError.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAEzC,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,SAAS,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,wBAAgB,cAAc,CAAC,KAAK,EAAE,GAAG,GAAG,eAAe,CAkG1D"}

package/dist/errors/normalizeError.js

@@ -0,0 +1,79 @@
+import { ErrorCode } from "./errorCodes";
+export function normalizeError(error) {
+    if (error?.name === "AbortError" || error?.message?.includes("timeout")) {
+        return {
+            code: ErrorCode.TIMEOUT,
+            message: "Request timeout",
+            status: 408,
+        };
+    }
+    if (error?.code === "ENOTFOUND" ||
+        error?.code === "ECONNREFUSED" ||
+        error?.message?.includes("fetch failed")) {
+        return {
+            code: ErrorCode.NETWORK_ERROR,
+            message: "Network error",
+            status: 0,
+        };
+    }
+    const status = error?.status || error?.response?.status;
+    if (status === 401 || status === 403) {
+        return {
+            code: ErrorCode.UNAUTHORIZED,
+            message: error?.message || "Unauthorized",
+            status,
+        };
+    }
+    if (status === 400) {
+        return {
+            code: ErrorCode.BAD_REQUEST,
+            message: error?.message || "Bad request",
+            status,
+        };
+    }
+    if (status === 503) {
+        return {
+            code: ErrorCode.PROVIDER_DOWN,
+            message: error?.message || "Provider unavailable",
+            status,
+        };
+    }
+    const errorMessage = error?.message?.toLowerCase() || "";
+    if (errorMessage.includes("no api key") ||
+        errorMessage.includes("api key required")) {
+        return {
+            code: ErrorCode.NO_API_KEY,
+            message: error?.message || "No API key provided",
+            status,
+        };
+    }
+    if (errorMessage.includes("model disabled") ||
+        errorMessage.includes("model not available")) {
+        return {
+            code: ErrorCode.MODEL_DISABLED,
+            message: error?.message || "Model disabled",
+            status,
+        };
+    }
+    if (errorMessage.includes("pricing unavailable") ||
+        errorMessage.includes("pricing not found")) {
+        return {
+            code: ErrorCode.PRICING_UNAVAILABLE,
+            message: error?.message || "Pricing unavailable",
+            status,
+        };
+    }
+    if (errorMessage.includes("insufficient tokens") ||
+        errorMessage.includes("not enough tokens")) {
+        return {
+            code: ErrorCode.INSUFFICIENT_TOKENS,
+            message: error?.message || "Insufficient tokens",
+            status,
+        };
+    }
+    return {
+        code: ErrorCode.UNKNOWN,
+        message: error?.message || "Unknown error",
+        status,
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./types";
+export * from "./errors/errorCodes";
+export * from "./errors/normalizeError";
+export * from "./client/createClient";
+//# 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":"AAAA,cAAc,SAAS,CAAC;AACxB,cAAc,qBAAqB,CAAC;AACpC,cAAc,yBAAyB,CAAC;AACxC,cAAc,uBAAuB,CAAC"}

package/dist/index.js

@@ -0,0 +1,4 @@
+export * from "./types";
+export * from "./errors/errorCodes";
+export * from "./errors/normalizeError";
+export * from "./client/createClient";

package/dist/route-handlers/nextjs/gateway.d.ts

@@ -0,0 +1,12 @@
+import { NextRequest } from "next/server";
+export declare function GET(request: NextRequest, context: {
+    params: Promise<{
+        path: string[];
+    }>;
+}): Promise<any>;
+export declare function POST(request: NextRequest, context: {
+    params: Promise<{
+        path: string[];
+    }>;
+}): Promise<any>;
+//# sourceMappingURL=gateway.d.ts.map

package/dist/route-handlers/nextjs/gateway.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gateway.d.ts","sourceRoot":"","sources":["../../../src/route-handlers/nextjs/gateway.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAgB,MAAM,aAAa,CAAC;AAwExD,wBAAsB,GAAG,CACvB,OAAO,EAAE,WAAW,EACpB,OAAO,EAAE;IAAE,MAAM,EAAE,OAAO,CAAC;QAAE,IAAI,EAAE,MAAM,EAAE,CAAA;KAAE,CAAC,CAAA;CAAE,gBAGjD;AAED,wBAAsB,IAAI,CACxB,OAAO,EAAE,WAAW,EACpB,OAAO,EAAE;IAAE,MAAM,EAAE,OAAO,CAAC;QAAE,IAAI,EAAE,MAAM,EAAE,CAAA;KAAE,CAAC,CAAA;CAAE,gBAGjD"}

package/dist/route-handlers/nextjs/gateway.js

@@ -0,0 +1,54 @@
+import { NextResponse } from "next/server";
+/**
+ * Next.js App Router gateway for LastBrain AI API
+ *
+ * Usage in app/api/lastbrain/[...path]/route.ts:
+ * export { GET, POST } from "@lastbrain/ai-ui-core/route-handlers/nextjs/gateway";
+ *
+ * This proxies requests to https://ai.lastbrain.io/api/public/v1/[...path]
+ */
+const LB_API_KEY = process.env.LB_API_KEY;
+const LB_BASE_URL = process.env.LB_BASE_URL || "https://ai.lastbrain.io";
+if (!LB_API_KEY) {
+    console.warn("⚠️  LB_API_KEY not found in environment variables. AI features will not work.");
+}
+async function handleRequest(request, context) {
+    if (!LB_API_KEY) {
+        return NextResponse.json({ error: "LB_API_KEY not configured" }, { status: 500 });
+    }
+    const params = await context.params;
+    const path = params.path.join("/");
+    const url = `${LB_BASE_URL}/api/public/v1/${path}`;
+    try {
+        const headers = {
+            Authorization: `Bearer ${LB_API_KEY}`,
+            "Content-Type": "application/json",
+        };
+        let body;
+        if (request.method === "POST") {
+            const json = await request.json();
+            body = JSON.stringify(json);
+        }
+        const response = await fetch(url, {
+            method: request.method,
+            headers,
+            body,
+        });
+        if (!response.ok) {
+            const errorText = await response.text();
+            return NextResponse.json({ error: errorText || "API request failed" }, { status: response.status });
+        }
+        const data = await response.json();
+        return NextResponse.json(data);
+    }
+    catch (error) {
+        console.error("LastBrain API gateway error:", error);
+        return NextResponse.json({ error: "Internal server error" }, { status: 500 });
+    }
+}
+export async function GET(request, context) {
+    return handleRequest(request, context);
+}
+export async function POST(request, context) {
+    return handleRequest(request, context);
+}

package/dist/route-handlers/nextjs/gateway.ts

@@ -0,0 +1,93 @@
+import { NextRequest, NextResponse } from "next/server";
+
+/**
+ * Next.js App Router gateway for LastBrain AI API
+ *
+ * Usage in app/api/lastbrain/[...path]/route.ts:
+ * export { GET, POST } from "@lastbrain/ai-ui-core/route-handlers/nextjs/gateway";
+ *
+ * This proxies requests to https://ai.lastbrain.io/api/public/v1/[...path]
+ */
+
+const LB_API_KEY = process.env.LB_API_KEY;
+const LB_BASE_URL =
+  process.env.LB_BASE_URL || "https://ai.lastbrain.io/api/public/v1";
+
+if (!LB_API_KEY) {
+  console.warn(
+    "⚠️  LB_API_KEY not found in environment variables. AI features will not work."
+  );
+}
+
+async function handleRequest(
+  request: NextRequest,
+  context: { params: Promise<{ path: string[] }> }
+) {
+  if (!LB_API_KEY) {
+    return NextResponse.json(
+      { error: "LB_API_KEY not configured" },
+      { status: 500 }
+    );
+  }
+
+  const params = await context.params;
+  const rawPath = params.path.join("/");
+  // Remove leading slash to avoid double slash
+  const path = rawPath.startsWith("/") ? rawPath.slice(1) : rawPath;
+  const url = `${LB_BASE_URL}/${path}`;
+  console.log("[Gateway] Proxying to:", url);
+  console.log(
+    "[Gateway] Bearer token:",
+    LB_API_KEY ? `${LB_API_KEY.substring(0, 10)}...` : "MISSING"
+  );
+
+  try {
+    const headers: HeadersInit = {
+      Authorization: `Bearer ${LB_API_KEY}`,
+      "Content-Type": "application/json",
+    };
+
+    let body: string | undefined;
+    if (request.method === "POST") {
+      const json = await request.json();
+      body = JSON.stringify(json);
+    }
+
+    const response = await fetch(url, {
+      method: request.method,
+      headers,
+      body,
+    });
+
+    if (!response.ok) {
+      const errorText = await response.text();
+      return NextResponse.json(
+        { error: errorText || "API request failed" },
+        { status: response.status }
+      );
+    }
+
+    const data = await response.json();
+    return NextResponse.json(data);
+  } catch (error) {
+    console.error("LastBrain API gateway error:", error);
+    return NextResponse.json(
+      { error: "Internal server error" },
+      { status: 500 }
+    );
+  }
+}
+
+export async function GET(
+  request: NextRequest,
+  context: { params: Promise<{ path: string[] }> }
+) {
+  return handleRequest(request, context);
+}
+
+export async function POST(
+  request: NextRequest,
+  context: { params: Promise<{ path: string[] }> }
+) {
+  return handleRequest(request, context);
+}