@serii84/vertex-partner-provider 1.0.15 → 1.0.19

package/index.js

@@ -1,6 +1,6 @@
 /**
  * Vertex Partner Provider for OpenCode
- * v1.0.15 - No transform, pass through raw (debug)
+ * v1.0.19 - Fix response body consumption issue
  */
 
 const { createOpenAICompatible } = require('@ai-sdk/openai-compatible');
@@ -20,6 +20,144 @@ async function getAuthToken(googleAuthOptions) {
   return token.token;
 }
 
+function cleanResponse(parsed) {
+  if (parsed.choices) {
+    for (const choice of parsed.choices) {
+      delete choice.matched_stop;
+      delete choice.logprobs;
+      
+      if (choice.delta) {
+        if (!choice.delta.content && choice.delta.reasoning_content) {
+          choice.delta.content = choice.delta.reasoning_content;
+        }
+        delete choice.delta.reasoning_content;
+      }
+      
+      if (choice.message) {
+        if (!choice.message.content && choice.message.reasoning_content) {
+          choice.message.content = choice.message.reasoning_content;
+        }
+        delete choice.message.reasoning_content;
+      }
+    }
+  }
+  
+  if (parsed.usage) {
+    const { prompt_tokens, completion_tokens, total_tokens } = parsed.usage;
+    parsed.usage = { prompt_tokens, completion_tokens, total_tokens };
+  }
+  
+  delete parsed.metadata;
+  
+  return parsed;
+}
+
+function transformStream(response) {
+  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) {
+          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]') {
+              controller.enqueue(encoder.encode('data: [DONE]\n\n'));
+              continue;
+            }
+            
+            try {
+              const parsed = JSON.parse(data);
+              
+              // Skip empty choices (usage-only chunk)
+              if (parsed.choices && parsed.choices.length === 0) {
+                continue;
+              }
+              
+              const cleaned = cleanResponse(parsed);
+              controller.enqueue(encoder.encode('data: ' + JSON.stringify(cleaned) + '\n\n'));
+            } catch (e) {
+              // Skip invalid JSON
+            }
+          }
+        }
+      } catch (err) {
+        controller.error(err);
+      }
+    },
+    
+    cancel() {
+      reader.cancel();
+    }
+  });
+  
+  return new Response(transformedStream, {
+    headers: response.headers,
+    status: response.status,
+    statusText: response.statusText,
+  });
+}
+
+async function transformNonStreamingResponse(response) {
+  const text = await response.text();
+  
+  // Handle empty response
+  if (!text || text.trim() === '') {
+    return new Response(JSON.stringify({
+      id: 'empty',
+      object: 'chat.completion',
+      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' },
+      status: response.status,
+      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,
+      statusText: response.statusText,
+    });
+  }
+}
+
 function createVertexPartner(options = {}) {
   const {
     project = process.env.GOOGLE_VERTEX_PROJECT,
@@ -42,8 +180,26 @@ function createVertexPartner(options = {}) {
     const headers = new Headers(init?.headers);
     headers.set('Authorization', `Bearer ${token}`);
     
-    // Just pass through - no transform
-    return fetch(url, { ...init, headers });
+    let isStreaming = false;
+    if (init?.body) {
+      try {
+        const body = JSON.parse(init.body);
+        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);
+    }
   };
 
   const provider = createOpenAICompatible({

package/package.json

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