@blaxel/llamaindex 0.2.49-dev.213 → 0.2.49-dev1

package/dist/index.d.ts

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

package/dist/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+require("./telemetry.js");
+__exportStar(require("./model.js"), exports);
+__exportStar(require("./tools.js"), exports);

package/dist/model.d.ts

@@ -0,0 +1,2 @@
+import type { ToolCallLLM, ToolCallLLMMessageOptions } from '@llamaindex/core/llms' with { "resolution-mode": "import" };
+export declare const blModel: (model: string, options?: Record<string, unknown>) => Promise<ToolCallLLM<object, ToolCallLLMMessageOptions>>;

package/dist/model.js

@@ -0,0 +1,139 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.blModel = void 0;
+const core_1 = require("@blaxel/core");
+const anthropic_1 = require("@llamaindex/anthropic");
+const google_1 = require("@llamaindex/google");
+const openai_1 = require("@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 (0, core_1.authenticate)();
+        const url = `${core_1.settings.runUrl}/${core_1.settings.workspace}/models/${this.model}`;
+        if (this.type === "mistral") {
+            return (0, openai_1.openai)({
+                model: this.modelData?.spec?.runtime?.model,
+                apiKey: core_1.settings.token,
+                baseURL: `${url}/v1`,
+                ...this.options,
+            });
+        }
+        if (this.type === "anthropic") {
+            const llm = (0, anthropic_1.anthropic)({
+                model: this.modelData?.spec?.runtime?.model,
+                session: new anthropic_1.AnthropicSession({
+                    baseURL: url,
+                    defaultHeaders: core_1.settings.headers,
+                }),
+                ...this.options,
+            });
+            return {
+                ...llm,
+                supportToolCall: true,
+            };
+        }
+        if (this.type === "cohere") {
+            const llm = (0, openai_1.openai)({
+                model: this.modelData?.spec?.runtime?.model,
+                apiKey: core_1.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 google_1.Gemini({
+                apiKey: core_1.settings.token,
+                model: this.modelData?.spec?.runtime?.model,
+                httpOptions: {
+                    baseUrl: url,
+                    headers: core_1.settings.headers,
+                },
+                ...this.options,
+            });
+            return llm;
+        }
+        return (0, openai_1.openai)({
+            model: this.modelData?.spec?.runtime?.model,
+            apiKey: core_1.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);
+        }
+    }
+}
+const blModel = async (model, options) => {
+    const modelData = await (0, core_1.getModelMetadata)(model);
+    if (!modelData) {
+        throw new Error(`Model ${model} not found`);
+    }
+    try {
+        return new BlaxelLLM(model, modelData, options);
+    }
+    catch (err) {
+        (0, core_1.handleDynamicImportError)(err);
+        throw err;
+    }
+};
+exports.blModel = blModel;

package/dist/telemetry.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/telemetry.js

@@ -0,0 +1,25 @@
+"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));
+});

package/dist/tools.d.ts

@@ -0,0 +1,7 @@
+import { ToolOptions } from "@blaxel/core/tools/mcpTool";
+export declare const blTool: (name: string, options?: ToolOptions | number) => Promise<import("llamaindex").FunctionTool<{
+    [x: string]: any;
+}, import("llamaindex").JSONValue | Promise<import("llamaindex").JSONValue>, object>[]>;
+export declare const blTools: (names: string[], ms?: number) => Promise<import("llamaindex").FunctionTool<{
+    [x: string]: any;
+}, import("llamaindex").JSONValue | Promise<import("llamaindex").JSONValue>, object>[]>;

package/dist/tools.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.blTools = exports.blTool = void 0;
+// @ts-ignore - Required for build time due to missing types in 'llamaindex'
+const core_1 = require("@blaxel/core");
+const llamaindex_1 = require("llamaindex");
+const blTool = async (name, options) => {
+    try {
+        const blaxelTool = await (0, core_1.getTool)(name, options);
+        const tools = blaxelTool.map((t) => {
+            // @ts-ignore - Required for build time due to missing types in 'llamaindex'
+            return (0, llamaindex_1.tool)(t.call.bind(t), {
+                name: t.name,
+                description: t.description,
+                parameters: t.inputSchema,
+            });
+        });
+        return tools;
+    }
+    catch (err) {
+        (0, core_1.handleDynamicImportError)(err);
+        throw err;
+    }
+};
+exports.blTool = blTool;
+const blTools = async (names, ms) => {
+    const toolArrays = await Promise.all(names.map((n) => (0, exports.blTool)(n, ms)));
+    return toolArrays.flat();
+};
+exports.blTools = blTools;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blaxel/llamaindex",
-  "version": "0.2.49-dev.213",
+  "version": "0.2.49-dev1",
   "description": "Blaxel SDK for TypeScript",
   "license": "MIT",
   "author": "Blaxel, INC (https://blaxel.ai)",
@@ -48,7 +48,7 @@
     "@opentelemetry/instrumentation": "^0.203.0",
     "@traceloop/instrumentation-llamaindex": "^0.14.0",
     "llamaindex": "^0.11.13",
-    "@blaxel/core": "0.2.49-dev.213"
+    "@blaxel/core": "0.2.49-dev1"
   },
   "devDependencies": {
     "@eslint/js": "^9.30.1",