@blaxel/llamaindex 0.2.36-dev.185 → 0.2.36-dev.190

package/dist/esm/index.js

@@ -0,0 +1,3 @@
+import "./telemetry.js";
+export * from "./model.js";
+export * from "./tools.js";

package/dist/esm/model.js

@@ -0,0 +1,135 @@
+import { authenticate, getModelMetadata, handleDynamicImportError, settings } from "@blaxel/core";
+import { anthropic, AnthropicSession } from "@llamaindex/anthropic";
+import { Gemini } from "@llamaindex/google";
+import { openai } from "@llamaindex/openai";
+// Custom LLM provider that refreshes auth on each call
+class BlaxelLLM {
+    model;
+    options;
+    modelData;
+    type;
+    _metadata;
+    constructor(model, modelData, options) {
+        this.model = model;
+        this.modelData = modelData;
+        this.options = options;
+        this.type = modelData?.spec?.runtime?.type || "openai";
+    }
+    get supportToolCall() {
+        return true;
+    }
+    get metadata() {
+        // Return cached metadata or default values
+        if (this._metadata) {
+            return this._metadata;
+        }
+        // Return default values with overrides from options
+        return {
+            model: this.model,
+            temperature: this.options?.temperature ?? 0,
+            topP: this.options?.topP ?? 1,
+            maxTokens: this.options?.maxTokens ?? undefined,
+            contextWindow: this.options?.contextWindow ?? 4096,
+            tokenizer: undefined, // Let the underlying LLM handle tokenizer
+            structuredOutput: this.options?.structuredOutput ?? false,
+        };
+    }
+    async ensureMetadata() {
+        if (!this._metadata) {
+            const llm = await this.createLLM();
+            this._metadata = llm.metadata;
+        }
+    }
+    async createLLM() {
+        await authenticate();
+        const url = `${settings.runUrl}/${settings.workspace}/models/${this.model}`;
+        if (this.type === "mistral") {
+            return openai({
+                model: this.modelData?.spec?.runtime?.model,
+                apiKey: settings.token,
+                baseURL: `${url}/v1`,
+                ...this.options,
+            });
+        }
+        if (this.type === "anthropic") {
+            const llm = anthropic({
+                model: this.modelData?.spec?.runtime?.model,
+                session: new AnthropicSession({
+                    baseURL: url,
+                    defaultHeaders: settings.headers,
+                }),
+                ...this.options,
+            });
+            return {
+                ...llm,
+                supportToolCall: true,
+            };
+        }
+        if (this.type === "cohere") {
+            const llm = openai({
+                model: this.modelData?.spec?.runtime?.model,
+                apiKey: settings.token,
+                baseURL: `${url}/compatibility/v1`,
+                ...this.options,
+            });
+            return {
+                ...llm,
+                supportToolCall: true,
+            };
+        }
+        if (this.type === "gemini") {
+            process.env.GOOGLE_API_KEY = process.env.GOOGLE_API_KEY || "THIS_IS_A_DUMMY_KEY_FOR_LLAMAINDEX";
+            const llm = new Gemini({
+                apiKey: settings.token,
+                model: this.modelData?.spec?.runtime?.model,
+                httpOptions: {
+                    baseUrl: url,
+                    headers: settings.headers,
+                },
+                ...this.options,
+            });
+            return llm;
+        }
+        return openai({
+            model: this.modelData?.spec?.runtime?.model,
+            apiKey: settings.token,
+            baseURL: `${url}/v1`,
+            ...this.options,
+        });
+    }
+    async chat(params) {
+        await this.ensureMetadata();
+        const llm = await this.createLLM();
+        // Type guard to handle overloads
+        if ('stream' in params && params.stream === true) {
+            return llm.chat(params);
+        }
+        else {
+            return llm.chat(params);
+        }
+    }
+    async complete(params) {
+        await this.ensureMetadata();
+        const llm = await this.createLLM();
+        // Type guard to handle overloads
+        if ('stream' in params && params.stream === true) {
+            return llm.complete(params);
+        }
+        else {
+            return llm.complete(params);
+        }
+    }
+}
+export const blModel = async (model, options) => {
+    const modelData = await getModelMetadata(model);
+    if (!modelData) {
+        throw new Error(`Model ${model} not found`);
+    }
+    try {
+        return new BlaxelLLM(model, modelData, options);
+    }
+    catch (err) {
+        handleDynamicImportError(err);
+        throw err;
+    }
+};

package/dist/esm/package.json

@@ -0,0 +1 @@
+{"type":"module"}

package/dist/esm/telemetry.js

@@ -0,0 +1,23 @@
+import { logger } from "@blaxel/core";
+import { registerInstrumentations } from "@opentelemetry/instrumentation";
+// Safely initialize LlamaIndex telemetry instrumentation
+async function initializeTelemetry() {
+    try {
+        const { LlamaIndexInstrumentation } = await import("@traceloop/instrumentation-llamaindex");
+        const llamaindex = new LlamaIndexInstrumentation();
+        // Try to enable the instrumentation
+        llamaindex.enable();
+        registerInstrumentations({
+            instrumentations: [llamaindex],
+        });
+    }
+    catch (error) {
+        // Log the error but don't crash the application
+        logger.warn("LlamaIndex telemetry instrumentation failed to initialize:", error instanceof Error ? error.message : String(error));
+        logger.warn("Continuing without LlamaIndex-specific telemetry...");
+    }
+}
+// Initialize telemetry asynchronously
+initializeTelemetry().catch((error) => {
+    logger.warn("Failed to initialize telemetry:", error instanceof Error ? error.message : String(error));
+});

package/dist/esm/tools.js

@@ -0,0 +1,25 @@
+// @ts-ignore - Required for build time due to missing types in 'llamaindex'
+import { getTool, handleDynamicImportError } from "@blaxel/core";
+import { tool } from "llamaindex";
+export const blTool = async (name, options) => {
+    try {
+        const blaxelTool = await getTool(name, options);
+        const tools = blaxelTool.map((t) => {
+            // @ts-ignore - Required for build time due to missing types in 'llamaindex'
+            return tool(t.call.bind(t), {
+                name: t.name,
+                description: t.description,
+                parameters: t.inputSchema,
+            });
+        });
+        return tools;
+    }
+    catch (err) {
+        handleDynamicImportError(err);
+        throw err;
+    }
+};
+export const blTools = async (names, ms) => {
+    const toolArrays = await Promise.all(names.map((n) => blTool(n, ms)));
+    return toolArrays.flat();
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blaxel/llamaindex",
-  "version": "0.2.36-dev.185",
+  "version": "0.2.36-dev.190",
   "description": "Blaxel SDK for TypeScript",
   "license": "MIT",
   "author": "Blaxel, INC (https://blaxel.ai)",
@@ -17,38 +17,22 @@
     "agent",
     "mcp"
   ],
-  "main": "dist/index.js",
-  "module": "dist/index.js",
-  "types": "dist/index.d.ts",
+  "main": "./dist/cjs/index.js",
+  "module": "./dist/esm/index.js",
+  "types": "./dist/cjs/types/index.d.ts",
   "exports": {
     ".": {
-      "import": {
-        "types": "./dist/index.d.ts",
-        "default": "./dist/index.js"
-      },
-      "require": {
-        "types": "./dist/index.d.ts",
-        "default": "./dist/index.js"
-      }
+      "types": "./dist/cjs/types/index.d.ts",
+      "import": "./dist/esm/index.js",
+      "require": "./dist/cjs/index.js",
+      "default": "./dist/cjs/index.js"
     },
-    "./*": {
-      "import": {
-        "types": "./dist/*.d.ts",
-        "default": "./dist/*.js"
-      },
-      "require": {
-        "types": "./dist/*.d.ts",
-        "default": "./dist/*.js"
-      }
-    }
+    "./package.json": "./package.json"
   },
   "typesVersions": {
     "*": {
       ".": [
-        "./dist/index.d.ts"
-      ],
-      "*": [
-        "./dist/*"
+        "./dist/cjs/types/index.d.ts"
       ]
     }
   },
@@ -64,7 +48,7 @@
     "@opentelemetry/instrumentation": "^0.203.0",
     "@traceloop/instrumentation-llamaindex": "^0.14.0",
     "llamaindex": "^0.11.13",
-    "@blaxel/core": "0.2.36-dev.185"
+    "@blaxel/core": "0.2.36-dev.190"
   },
   "devDependencies": {
     "@eslint/js": "^9.30.1",
@@ -75,6 +59,10 @@
   "scripts": {
     "lint": "eslint src/",
     "dev": "tsc --watch",
-    "build": "tsc"
+    "build": "npm run build:cjs && npm run build:esm && npm run build:fix-esm && npm run build:esm-package",
+    "build:cjs": "NODE_OPTIONS='--max-old-space-size=8192' tsc -p tsconfig.cjs.json",
+    "build:esm": "NODE_OPTIONS='--max-old-space-size=8192' tsc -p tsconfig.esm.json",
+    "build:fix-esm": "node fix-esm-imports.js",
+    "build:esm-package": "echo '{\"type\":\"module\"}' > dist/esm/package.json"
   }
 }

package/dist/telemetry.js

@@ -1,25 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const core_1 = require("@blaxel/core");
-const instrumentation_1 = require("@opentelemetry/instrumentation");
-// Safely initialize LlamaIndex telemetry instrumentation
-async function initializeTelemetry() {
-    try {
-        const { LlamaIndexInstrumentation } = await import("@traceloop/instrumentation-llamaindex");
-        const llamaindex = new LlamaIndexInstrumentation();
-        // Try to enable the instrumentation
-        llamaindex.enable();
-        (0, instrumentation_1.registerInstrumentations)({
-            instrumentations: [llamaindex],
-        });
-    }
-    catch (error) {
-        // Log the error but don't crash the application
-        core_1.logger.warn("LlamaIndex telemetry instrumentation failed to initialize:", error instanceof Error ? error.message : String(error));
-        core_1.logger.warn("Continuing without LlamaIndex-specific telemetry...");
-    }
-}
-// Initialize telemetry asynchronously
-initializeTelemetry().catch((error) => {
-    core_1.logger.warn("Failed to initialize telemetry:", error instanceof Error ? error.message : String(error));
-});