@serii84/vertex-partner-provider 1.0.32 → 1.1.1

package/index.js

@@ -1,11 +1,13 @@
 /**
- * Vertex Partner Provider for OpenCode
- * v1.0.32 - Always include delta (required by OpenAI format)
+ * Vertex Partner Provider
+ * Enables Vertex AI partner models (GLM, Kimi, DeepSeek, MiniMax, Qwen) with AI SDK
  */
 
 const fs = require('fs');
-const path = require('path');
+const { createOpenAICompatible } = require('@ai-sdk/openai-compatible');
+const { GoogleAuth } = require('google-auth-library');
 
+// Optional debug logging
 const DEBUG = process.env.VERTEX_DEBUG === 'true';
 const DEBUG_FILE = process.env.VERTEX_DEBUG_FILE || '/tmp/vertex-debug.log';
 
@@ -16,9 +18,7 @@ function debugLog(...args) {
   fs.appendFileSync(DEBUG_FILE, `[${timestamp}] ${message}\n`);
 }
 
-const { createOpenAICompatible } = require('@ai-sdk/openai-compatible');
-const { GoogleAuth } = require('google-auth-library');
-
+// Auth client singleton
 let authClient = null;
 
 async function getAuthToken(googleAuthOptions) {
@@ -33,8 +33,11 @@ async function getAuthToken(googleAuthOptions) {
   return token.token;
 }
 
+/**
+ * Clean response to standard OpenAI format
+ * Removes vendor-specific fields and normalizes structure
+ */
 function cleanResponse(parsed) {
-  // Build a clean response with only standard OpenAI fields
   const cleaned = {
     id: parsed.id,
     object: parsed.object,
@@ -44,11 +47,9 @@ function cleanResponse(parsed) {
 
   if (parsed.choices) {
     cleaned.choices = parsed.choices.map(choice => {
-      const cleanChoice = {
-        index: choice.index,
-      };
+      const cleanChoice = { index: choice.index };
 
-      // Normalize finish_reason to a string (some models return an object)
+      // Handle finish_reason (normalize if object, ensure string)
       if (choice.finish_reason != null) {
         if (typeof choice.finish_reason === 'object') {
           cleanChoice.finish_reason = choice.finish_reason.type
@@ -60,23 +61,26 @@ function cleanResponse(parsed) {
         }
       }
 
-      // Clean up delta - always include it (OpenAI format requires delta on all streaming chunks)
+      // Keep logprobs if present (standard OpenAI field)
+      if (choice.logprobs != null) cleanChoice.logprobs = choice.logprobs;
+
+      // Clean delta for streaming responses
       if (choice.delta) {
         const cleanDelta = {};
         if (choice.delta.role) cleanDelta.role = choice.delta.role;
         if (choice.delta.content) cleanDelta.content = choice.delta.content;
-        else if (choice.delta.reasoning_content) cleanDelta.content = choice.delta.reasoning_content;
+        // Preserve reasoning_content for AI SDK's native reasoning support
+        if (choice.delta.reasoning_content) cleanDelta.reasoning_content = choice.delta.reasoning_content;
         if (choice.delta.tool_calls) cleanDelta.tool_calls = choice.delta.tool_calls;
         cleanChoice.delta = cleanDelta;
-      } else {
-        // Always include delta, even if empty (required by OpenAI format)
-        cleanChoice.delta = {};
       }
 
+      // Clean message for non-streaming responses
       if (choice.message) {
         const cleanMessage = { role: choice.message.role };
         if (choice.message.content) cleanMessage.content = choice.message.content;
-        else if (choice.message.reasoning_content) cleanMessage.content = choice.message.reasoning_content;
+        // Preserve reasoning_content for AI SDK's native reasoning support
+        if (choice.message.reasoning_content) cleanMessage.reasoning_content = choice.message.reasoning_content;
         if (choice.message.tool_calls) cleanMessage.tool_calls = choice.message.tool_calls;
         cleanChoice.message = cleanMessage;
       }
@@ -85,7 +89,7 @@ function cleanResponse(parsed) {
     });
   }
 
-  // Clean usage - only keep standard fields
+  // Clean usage - only standard fields
   if (parsed.usage) {
     const { prompt_tokens, completion_tokens, total_tokens } = parsed.usage;
     if (prompt_tokens != null || completion_tokens != null || total_tokens != null) {
@@ -96,84 +100,78 @@ function cleanResponse(parsed) {
   return cleaned;
 }
 
+/**
+ * Transform SSE stream to clean format
+ */
 function transformStream(response) {
-  // Log response headers for debugging
   debugLog('Response headers:', Object.fromEntries(response.headers.entries()));
 
   const reader = response.body.getReader();
   const decoder = new TextDecoder();
   const encoder = new TextEncoder();
-
   let buffer = '';
-  
+
   const transformedStream = new ReadableStream({
     async pull(controller) {
       try {
         const { done, value } = await reader.read();
-        
+
         if (done) {
-          // Process any remaining data in buffer
-          if (buffer.trim()) {
-            debugLog('Processing remaining buffer:', buffer);
-            if (buffer.startsWith('data: ')) {
-              const data = buffer.slice(6).trim();
-              if (data === '[DONE]') {
-                controller.enqueue(encoder.encode('data: [DONE]\n\n'));
-              } else if (data) {
-                try {
-                  const parsed = JSON.parse(data);
-                  const cleaned = cleanResponse(parsed);
-                  if (cleaned.choices && cleaned.choices.length > 0) {
-                    controller.enqueue(encoder.encode('data: ' + JSON.stringify(cleaned) + '\n\n'));
-                  }
-                } catch (e) {
-                  debugLog('Final buffer parse error:', e.message);
+          // Process remaining buffer
+          if (buffer.trim() && buffer.startsWith('data: ')) {
+            const data = buffer.slice(6).trim();
+            if (data === '[DONE]') {
+              controller.enqueue(encoder.encode('data: [DONE]\n\n'));
+            } else if (data) {
+              try {
+                const parsed = JSON.parse(data);
+                const cleaned = cleanResponse(parsed);
+                if (cleaned.choices?.length > 0) {
+                  controller.enqueue(encoder.encode('data: ' + JSON.stringify(cleaned) + '\n\n'));
                 }
+              } catch (e) {
+                debugLog('Final buffer parse error:', e.message);
               }
             }
           }
           controller.close();
           return;
         }
-        
+
         buffer += decoder.decode(value, { stream: true });
-        
+
         let boundary;
         while ((boundary = buffer.indexOf('\n\n')) !== -1) {
           const message = buffer.slice(0, boundary);
           buffer = buffer.slice(boundary + 2);
-          
+
           if (!message.trim()) continue;
-          
+
           if (message.startsWith('data: ')) {
             const data = message.slice(6);
-            
+
             if (data === '[DONE]') {
               debugLog('Forwarding [DONE]');
               controller.enqueue(encoder.encode('data: [DONE]\n\n'));
               continue;
             }
-            
+
             try {
               const parsed = JSON.parse(data);
-
               debugLog('Raw chunk:', parsed);
 
               const cleaned = cleanResponse(parsed);
 
-              // Skip chunks with empty choices (including usage-only chunks)
-              // The AI SDK may not handle empty choices arrays correctly
-              if (!cleaned.choices || cleaned.choices.length === 0) {
-                debugLog('Skipping chunk with empty choices');
+              // Skip chunks with no useful data (no choices AND no usage)
+              if (!cleaned.choices?.length && !cleaned.usage) {
+                debugLog('Skipping empty chunk');
                 continue;
               }
 
               debugLog('Cleaned chunk:', cleaned);
-
               controller.enqueue(encoder.encode('data: ' + JSON.stringify(cleaned) + '\n\n'));
             } catch (e) {
-              debugLog('JSON parse error:', e.message, 'Data:', data);
-              // Skip invalid JSON
+              debugLog('JSON parse error:', e.message);
             }
           }
         }
@@ -181,12 +179,12 @@ function transformStream(response) {
         controller.error(err);
       }
     },
-    
+
     cancel() {
       reader.cancel();
     }
   });
-  
+
   return new Response(transformedStream, {
     headers: response.headers,
     status: response.status,
@@ -194,19 +192,17 @@ function transformStream(response) {
   });
 }
 
+/**
+ * Transform non-streaming response to clean format
+ */
 async function transformNonStreamingResponse(response) {
   const text = await response.text();
-  
-  // Handle empty response
-  if (!text || text.trim() === '') {
+
+  if (!text?.trim()) {
     return new Response(JSON.stringify({
       id: 'empty',
       object: 'chat.completion',
-      choices: [{
-        index: 0,
-        message: { role: 'assistant', content: '' },
-        finish_reason: 'stop'
-      }],
+      choices: [{ index: 0, message: { role: 'assistant', content: '' }, finish_reason: 'stop' }],
       usage: { prompt_tokens: 0, completion_tokens: 0, total_tokens: 0 }
     }), {
       headers: { 'content-type': 'application/json' },
@@ -214,18 +210,16 @@ async function transformNonStreamingResponse(response) {
       statusText: response.statusText,
     });
   }
-  
+
   try {
     const data = JSON.parse(text);
     const cleaned = cleanResponse(data);
-    
     return new Response(JSON.stringify(cleaned), {
       headers: { 'content-type': 'application/json' },
       status: response.status,
       statusText: response.statusText,
     });
   } catch (e) {
-    // If JSON parse fails, return original text as-is
     return new Response(text, {
       headers: response.headers,
       status: response.status,
@@ -234,6 +228,14 @@ async function transformNonStreamingResponse(response) {
   }
 }
 
+/**
+ * Create a Vertex AI partner model provider
+ * @param {Object} options
+ * @param {string} options.project - GCP project ID (or GOOGLE_VERTEX_PROJECT env var)
+ * @param {string} options.location - GCP region (default: 'global')
+ * @param {string} options.publisher - Model publisher (e.g., 'zai-org', 'moonshotai', 'deepseek-ai')
+ * @param {Object} options.googleAuthOptions - Additional GoogleAuth options
+ */
 function createVertexPartner(options = {}) {
   const {
     project = process.env.GOOGLE_VERTEX_PROJECT,
@@ -245,17 +247,17 @@ function createVertexPartner(options = {}) {
   if (!project) throw new Error('project is required');
   if (!publisher) throw new Error('publisher is required');
 
-  const baseHost = location === 'global' 
-    ? 'aiplatform.googleapis.com' 
+  const baseHost = location === 'global'
+    ? 'aiplatform.googleapis.com'
     : `${location}-aiplatform.googleapis.com`;
-  
+
   const baseURL = `https://${baseHost}/v1/projects/${project}/locations/${location}/endpoints/openapi`;
 
   const authFetch = async (url, init) => {
     const token = await getAuthToken(googleAuthOptions);
     const headers = new Headers(init?.headers);
     headers.set('Authorization', `Bearer ${token}`);
-    
+
     let isStreaming = false;
     if (init?.body) {
       try {
@@ -263,27 +265,22 @@ function createVertexPartner(options = {}) {
         isStreaming = body.stream === true;
       } catch (e) {}
     }
-    
+
     const response = await fetch(url, { ...init, headers });
-    
-    if (!response.ok) {
-      // Clone and return error responses as-is
-      return response;
-    }
-    
-    if (isStreaming) {
-      return transformStream(response);
-    } else {
-      return transformNonStreamingResponse(response);
-    }
+
+    if (!response.ok) return response;
+
+    return isStreaming ? transformStream(response) : transformNonStreamingResponse(response);
   };
 
   const provider = createOpenAICompatible({
     name: `vertex-${publisher}`,
     baseURL,
     fetch: authFetch,
+    includeUsage: true,
   });
 
+  // Wrap provider to auto-prefix model IDs with publisher
   const wrappedProvider = (modelId) => {
     const fullModelId = modelId.includes('/') ? modelId : `${publisher}/${modelId}`;
     return provider(fullModelId);
@@ -300,4 +297,4 @@ function createVertexPartner(options = {}) {
   return wrappedProvider;
 }
 
-module.exports = { createVertexPartner };
+module.exports = { createVertexPartner };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@serii84/vertex-partner-provider",
-  "version": "1.0.32",
+  "version": "1.1.1",
   "description": "Vertex AI partner models (GLM, Kimi, DeepSeek) for OpenCode",
   "main": "index.js",
   "scripts": {