@lay111/dsh-plugin-google 1.0.4 → 1.0.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lay111/dsh-plugin-google",
-  "version": "1.0.4",
+  "version": "1.0.5",
   "description": "Native DeepSeek Harness Plugin for Google Antigravity Pro & Gemini/Claude Models",
   "type": "module",
   "main": "src/index.js",

package/src/adapter.js

@@ -24,24 +24,35 @@ export class AntigravityLlmAdapter {
     }));
   }
 
-  async resolveModelInfo(provider, modelId, signal) {
+  async resolveModel(provider, modelId, signal) {
     const model = findModel(modelId);
     return {
       provider: 'antigravity',
       id: model.id,
       name: model.name,
-      contextWindow: model.contextWindow,
-      maxTokens: model.maxTokens,
-      reasoningEfforts: model.supportsThinking
-        ? [
-            { id: 'high', name: 'High Thinking' },
-            { id: 'low', name: 'Low Thinking' },
-          ]
+      inputModalities: ['text'],
+      context: { contextWindow: model.contextWindow },
+      defaultMaxTokens: model.maxTokens,
+      reasoning: model.supportsThinking
+        ? {
+            efforts: [
+              { id: 'high', name: 'High' },
+              { id: 'off', name: 'Off' },
+            ],
+            defaultEffort: 'high',
+          }
         : undefined,
     };
   }
 
-  async *generate(options, runtime) {
+  async prepareCall(provider, modelId, signal) {
+    return {
+      model: await this.resolveModel(provider, modelId, signal),
+      stream: (options) => this.stream(options),
+    };
+  }
+
+  async *stream(options) {
     const { accessToken, projectId } = await getValidAccessToken();
     yield* streamAntigravity(options, accessToken, projectId);
   }

package/src/api.js

@@ -24,8 +24,8 @@ export function formatMessagesToAntigravity(messages, modelSpec, projectId) {
       for (const block of message.content) {
         if (block.type === 'text') {
           parts.push({ text: block.text });
-        } else if (block.type === 'thought') {
-          parts.push({ thought: true, text: block.text });
+        } else if (block.type === 'thought' || block.type === 'reasoning') {
+          parts.push({ thought: true, text: block.text || block.thought || '' });
         } else if (block.type === 'tool-call') {
           parts.push({
             functionCall: {
@@ -128,47 +128,53 @@ export async function* streamAntigravity(options, accessToken, projectId) {
       buffer = lines.pop() || '';
 
       for (const line of lines) {
-        const trimmed = line.trim();
+        let trimmed = line.trim();
         if (!trimmed) continue;
+        if (trimmed.startsWith('data:')) {
+          trimmed = trimmed.slice(5).trim();
+        }
+        if (trimmed === '[DONE]') break;
 
         try {
-          const item = JSON.parse(trimmed);
-          const candidate = item.response?.candidates?.[0];
-          if (!candidate) continue;
+          const items = Array.isArray(JSON.parse(trimmed)) ? JSON.parse(trimmed) : [JSON.parse(trimmed)];
+          for (const item of items) {
+            const candidate = item.response?.candidates?.[0] || item.candidates?.[0];
+            if (!candidate) continue;
+
+            for (const part of candidate.content?.parts || []) {
+              if (part.thought) {
+                yield {
+                  type: 'reasoning-delta',
+                  index: blockIndex,
+                  text: part.text || '',
+                };
+              } else if (part.text) {
+                yield {
+                  type: 'text-delta',
+                  index: blockIndex,
+                  text: part.text || '',
+                };
+              } else if (part.functionCall) {
+                const callId = `call_${Math.random().toString(36).slice(2, 10)}`;
+                yield {
+                  type: 'tool-call-delta',
+                  index: blockIndex++,
+                  id: callId,
+                  name: part.functionCall.name,
+                  argumentsDelta: JSON.stringify(part.functionCall.args || {}),
+                };
+              }
+            }
 
-          for (const part of candidate.content?.parts || []) {
-            if (part.thought) {
-              yield {
-                type: 'reasoning-delta',
-                index: blockIndex,
-                text: part.text || '',
-              };
-            } else if (part.text) {
+            if (candidate.finishReason) {
               yield {
-                type: 'text-delta',
-                index: blockIndex,
-                text: part.text || '',
-              };
-            } else if (part.functionCall) {
-              const callId = `call_${Math.random().toString(36).slice(2, 10)}`;
-              yield {
-                type: 'tool-call-delta',
-                index: blockIndex++,
-                id: callId,
-                name: part.functionCall.name,
-                argumentsDelta: JSON.stringify(part.functionCall.args || {}),
+                type: 'finish',
+                reason: 'stop',
               };
             }
           }
-
-          if (candidate.finishReason) {
-            yield {
-              type: 'finish',
-              reason: candidate.finishReason.toLowerCase() === 'stop' ? 'stop' : 'stop',
-            };
-          }
         } catch {
-          // ignore partial json
+          // ignore partial chunks
         }
       }
     }