@blaxel/llamaindex 0.2.49 → 0.2.50-preview.115

package/dist/esm/model.js

@@ -36,40 +36,146 @@ class BlaxelLLM {
     }
     async ensureMetadata() {
         if (!this._metadata) {
-            const llm = await this.createLLM();
-            this._metadata = llm.metadata;
+            try {
+                const llm = await this.createLLM();
+                this._metadata = llm.metadata;
+            }
+            catch {
+                // If metadata access fails (e.g., Gemini), use default metadata
+                this._metadata = {
+                    model: this.modelData?.spec?.runtime?.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,
+                    structuredOutput: this.options?.structuredOutput ?? false,
+                };
+            }
         }
     }
     async createLLM() {
         await authenticate();
+        // Capture fresh headers and token after authentication
+        // Use getter to ensure we get the latest values
+        const currentToken = settings.token;
         const url = `${settings.runUrl}/${settings.workspace}/models/${this.model}`;
+        // Custom fetch function that adds authentication headers
+        const authenticatedFetch = async (input, init) => {
+            await authenticate();
+            // Get fresh headers after authentication
+            const freshHeaders = { ...settings.headers };
+            const headers = {
+                ...freshHeaders,
+                ...(init?.headers || {}),
+            };
+            // Ensure Content-Type is set for JSON requests if body exists and Content-Type is not already set
+            if (init?.body && !headers['Content-Type'] && !headers['content-type']) {
+                // If body is a string, check if it looks like JSON
+                if (typeof init.body === 'string') {
+                    const trimmed = init.body.trim();
+                    if (trimmed.startsWith('{') || trimmed.startsWith('[')) {
+                        headers['Content-Type'] = 'application/json';
+                    }
+                }
+                else {
+                    // For non-string bodies (FormData, Blob, etc.), let fetch handle it
+                    // For objects, assume JSON
+                    if (typeof init.body === 'object' && !(init.body instanceof FormData) && !(init.body instanceof Blob)) {
+                        headers['Content-Type'] = 'application/json';
+                    }
+                }
+            }
+            return fetch(input, {
+                ...init,
+                headers,
+            });
+        };
         if (this.type === "mistral") {
             return openai({
                 model: this.modelData?.spec?.runtime?.model,
-                apiKey: settings.token,
+                apiKey: currentToken,
                 baseURL: `${url}/v1`,
+                additionalSessionOptions: {
+                    fetch: authenticatedFetch,
+                },
                 ...this.options,
             });
         }
         if (this.type === "anthropic") {
+            // Set a dummy API key to satisfy AnthropicSession constructor requirement
+            // The actual authentication is handled via defaultHeaders
+            process.env.ANTHROPIC_API_KEY = process.env.ANTHROPIC_API_KEY || "dummy-key-for-blaxel";
+            // Get fresh headers right before creating the session
+            const anthropicHeaders = { ...settings.headers };
             const llm = anthropic({
                 model: this.modelData?.spec?.runtime?.model,
                 session: new AnthropicSession({
                     baseURL: url,
-                    defaultHeaders: settings.headers,
+                    defaultHeaders: anthropicHeaders,
                 }),
                 ...this.options,
             });
-            return {
+            // Wrap the LLM to normalize Anthropic's response format (array content -> string)
+            // Create overloaded chat function
+            const chatWrapper = async (params) => {
+                // Type guard to determine if params is streaming or non-streaming
+                const isStreaming = 'stream' in params && params.stream === true;
+                let response;
+                if (isStreaming) {
+                    response = await llm.chat(params);
+                }
+                else {
+                    response = await llm.chat(params);
+                }
+                // Handle streaming responses (AsyncIterable)
+                const isAsyncIterable = (value) => {
+                    return value !== null && typeof value === 'object' && Symbol.asyncIterator in value;
+                };
+                if (isAsyncIterable(response)) {
+                    return response; // Streaming responses are handled differently, return as-is
+                }
+                // Transform array content to string for non-streaming responses
+                const chatResponse = response;
+                if (chatResponse && typeof chatResponse === 'object' && chatResponse !== null && 'message' in chatResponse) {
+                    if (chatResponse.message && Array.isArray(chatResponse.message.content)) {
+                        const contentArray = chatResponse.message.content;
+                        const textContent = contentArray
+                            .filter((item) => item.type === 'text' && item.text)
+                            .map((item) => item.text)
+                            .join('');
+                        return {
+                            ...chatResponse,
+                            message: {
+                                ...chatResponse.message,
+                                content: textContent || chatResponse.message.content,
+                            },
+                        };
+                    }
+                }
+                return chatResponse;
+            };
+            // Add overload signatures
+            const chatWithOverloads = chatWrapper;
+            const wrappedLLM = {
                 ...llm,
                 supportToolCall: true,
+                chat: chatWithOverloads,
+                complete: llm.complete.bind(llm),
+                exec: llm.exec.bind(llm),
+                streamExec: llm.streamExec.bind(llm),
+                metadata: llm.metadata,
             };
+            return wrappedLLM;
         }
         if (this.type === "cohere") {
             const llm = openai({
                 model: this.modelData?.spec?.runtime?.model,
-                apiKey: settings.token,
-                baseURL: `${url}/compatibility/v1`,
+                apiKey: currentToken,
+                baseURL: `${url}/compatibility/v1`, // OpenAI compatibility endpoint
+                additionalSessionOptions: {
+                    fetch: authenticatedFetch,
+                },
                 ...this.options,
             });
             return {
@@ -92,8 +198,11 @@ class BlaxelLLM {
         }
         return openai({
             model: this.modelData?.spec?.runtime?.model,
-            apiKey: settings.token,
+            apiKey: currentToken,
             baseURL: `${url}/v1`,
+            additionalSessionOptions: {
+                fetch: authenticatedFetch,
+            },
             ...this.options,
         });
     }
@@ -119,6 +228,23 @@ class BlaxelLLM {
             return llm.complete(params);
         }
     }
+    async exec(params) {
+        await this.ensureMetadata();
+        const llm = await this.createLLM();
+        // Type guard to handle overloads
+        if ('stream' in params && params.stream === true) {
+            return llm.exec(params);
+        }
+        else {
+            return llm.exec(params);
+        }
+    }
+    // streamExec method
+    async streamExec(params) {
+        await this.ensureMetadata();
+        const llm = await this.createLLM();
+        return llm.streamExec(params);
+    }
 }
 export const blModel = async (model, options) => {
     const modelData = await getModelMetadata(model);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blaxel/llamaindex",
-  "version": "0.2.49",
+  "version": "0.2.50-preview.115",
   "description": "Blaxel SDK for TypeScript",
   "license": "MIT",
   "author": "Blaxel, INC (https://blaxel.ai)",
@@ -40,15 +40,15 @@
     "dist"
   ],
   "dependencies": {
-    "@llamaindex/anthropic": "^0.3.15",
-    "@llamaindex/core": "0.6.13",
-    "@llamaindex/google": "0.3.12",
-    "@llamaindex/mistral": "^0.1.13",
-    "@llamaindex/openai": "^0.4.7",
+    "@llamaindex/anthropic": "^0.3.26",
+    "@llamaindex/core": "0.6.22",
+    "@llamaindex/google": "0.3.22",
+    "@llamaindex/mistral": "^0.1.22",
+    "@llamaindex/openai": "^0.4.21",
     "@opentelemetry/instrumentation": "^0.203.0",
     "@traceloop/instrumentation-llamaindex": "^0.14.0",
-    "llamaindex": "^0.11.13",
-    "@blaxel/core": "0.2.49"
+    "llamaindex": "^0.12.0",
+    "@blaxel/core": "0.2.50-preview.115"
   },
   "devDependencies": {
     "@eslint/js": "^9.30.1",