@lay111/dsh-plugin-google 1.0.16 → 1.0.18

package/package.json

@@ -1,12 +1,17 @@
 {
   "name": "@lay111/dsh-plugin-google",
-  "version": "1.0.16",
+  "version": "1.0.18",
   "description": "Community-driven DeepSeek Harness Plugin for Google Antigravity & Gemini/Claude Models",
   "type": "module",
   "main": "src/index.js",
   "exports": {
     ".": "./src/index.js",
-    "./package.json": "./package.json"
+    "./package.json": "./package.json",
+    "./auth": "./src/auth.js",
+    "./models": "./src/models.js",
+    "./api": "./src/api.js",
+    "./adapter": "./src/adapter.js",
+    "./src/*": "./src/*"
   },
   "bin": {
     "dsh-plugin-google": "bin/setup.js",

package/src/api.js

@@ -8,37 +8,62 @@ const ANTIGRAVITY_ENDPOINTS = [
 
 export function cleanSchema(schema) {
   if (!schema || typeof schema !== 'object') return schema;
-  const clone = JSON.parse(JSON.stringify(schema));
-
-  function clean(obj) {
-    if (!obj || typeof obj !== 'object') return;
-    delete obj.$schema;
-    delete obj.$id;
-    delete obj.definitions;
-    delete obj.$defs;
-    delete obj.additionalProperties;
-
-    if (obj.properties && typeof obj.properties === 'object') {
-      for (const key of Object.keys(obj.properties)) {
-        clean(obj.properties[key]);
-      }
-    }
-    if (obj.items && typeof obj.items === 'object') {
-      clean(obj.items);
-    }
-    if (Array.isArray(obj.anyOf)) {
-      obj.anyOf.forEach(clean);
-    }
-    if (Array.isArray(obj.oneOf)) {
-      obj.oneOf.forEach(clean);
-    }
-    if (Array.isArray(obj.allOf)) {
-      obj.allOf.forEach(clean);
+  if (Array.isArray(schema)) return schema.map(cleanSchema);
+
+  // Handle anyOf / oneOf (Google Gemini rejects siblings with anyOf)
+  if (Array.isArray(schema.anyOf) || Array.isArray(schema.oneOf)) {
+    const variants = schema.anyOf || schema.oneOf;
+    const nonNull = variants.find((v) => v && v.type !== 'null') || variants[0];
+    const isNullable = variants.some((v) => v && v.type === 'null');
+    const merged = cleanSchema(nonNull);
+    if (isNullable && typeof merged === 'object' && merged !== null) merged.nullable = true;
+    return merged;
+  }
+
+  const cleaned = {};
+
+  // Normalize type array e.g. ["string", "null"] -> type: "string", nullable: true
+  if (Array.isArray(schema.type)) {
+    const hasNull = schema.type.includes('null');
+    const mainType = schema.type.find((t) => t !== 'null') || 'string';
+    cleaned.type = mainType;
+    if (hasNull) cleaned.nullable = true;
+  } else if (schema.type) {
+    cleaned.type = schema.type;
+  }
+
+  if (typeof schema.description === 'string' && schema.description.length > 0) {
+    cleaned.description = schema.description;
+  }
+
+  if (schema.nullable === true) {
+    cleaned.nullable = true;
+  }
+
+  if (typeof schema.format === 'string' && schema.format.length > 0) {
+    cleaned.format = schema.format;
+  }
+
+  if (Array.isArray(schema.enum)) {
+    cleaned.enum = schema.enum;
+  }
+
+  if (Array.isArray(schema.required)) {
+    cleaned.required = schema.required;
+  }
+
+  if (schema.properties && typeof schema.properties === 'object' && !Array.isArray(schema.properties)) {
+    cleaned.properties = {};
+    for (const [k, v] of Object.entries(schema.properties)) {
+      cleaned.properties[k] = cleanSchema(v);
     }
   }
 
-  clean(clone);
-  return clone;
+  if (schema.items && typeof schema.items === 'object') {
+    cleaned.items = cleanSchema(schema.items);
+  }
+
+  return cleaned;
 }
 
 export function formatMessagesToAntigravity(messages, modelSpec, projectId) {
@@ -223,7 +248,12 @@ export async function* streamAntigravity(options, accessToken, projectId) {
   const reader = response.body.getReader();
   const decoder = new TextDecoder();
   let buffer = '';
-  let blockIndex = 0;
+  let hasText = false;
+  let hasToolCall = false;
+  let accumulatedThoughts = '';
+  let nextBlockIndex = 0;
+  const reasoningBlockIndex = 0;
+  let textBlockIndex = 1;
 
   try {
     while (true) {
@@ -250,22 +280,26 @@ export async function* streamAntigravity(options, accessToken, projectId) {
 
             for (const part of candidate.content?.parts || []) {
               if (part.thought) {
+                accumulatedThoughts += part.text || '';
                 yield {
                   type: 'reasoning-delta',
-                  index: blockIndex,
+                  index: reasoningBlockIndex,
                   text: part.text || '',
                 };
               } else if (part.text) {
+                hasText = true;
                 yield {
                   type: 'text-delta',
-                  index: blockIndex,
+                  index: textBlockIndex,
                   text: part.text || '',
                 };
               } else if (part.functionCall) {
+                hasToolCall = true;
                 const callId = `call_${Math.random().toString(36).slice(2, 10)}`;
+                const callIndex = 2 + (nextBlockIndex++);
                 yield {
                   type: 'tool-call-delta',
-                  index: blockIndex++,
+                  index: callIndex,
                   id: callId,
                   name: part.functionCall.name,
                   argumentsDelta: JSON.stringify(part.functionCall.args || {}),
@@ -274,6 +308,17 @@ export async function* streamAntigravity(options, accessToken, projectId) {
             }
 
             if (candidate.finishReason) {
+              // Fallback protection: If the model only thought and emitted 0 text and 0 tool calls,
+              // synthesize a completion text so the turn never cuts off silently!
+              if (!hasText && !hasToolCall && accumulatedThoughts.length > 0) {
+                hasText = true;
+                yield {
+                  type: 'text-delta',
+                  index: textBlockIndex,
+                  text: '\n(已完成思考，请指示下一步)',
+                };
+              }
+
               yield {
                 type: 'finish',
                 reason: 'stop',
@@ -285,6 +330,19 @@ export async function* streamAntigravity(options, accessToken, projectId) {
         }
       }
     }
+
+    // Final safety check
+    if (!hasText && !hasToolCall && accumulatedThoughts.length > 0) {
+      yield {
+        type: 'text-delta',
+        index: textBlockIndex,
+        text: '\n(已完成思考，请指示下一步)',
+      };
+      yield {
+        type: 'finish',
+        reason: 'stop',
+      };
+    }
   } finally {
     reader.releaseLock();
   }

package/src/index.js

@@ -1,5 +1,10 @@
 import { AntigravityLlmAdapter } from './adapter.js';
 
+export * from './auth.js';
+export * from './models.js';
+export * from './api.js';
+export * from './adapter.js';
+
 export const name = 'dsh-antigravity';
 export const inject = ['llm'];
 

package/src/models.js

@@ -1,4 +1,14 @@
 export const ANTIGRAVITY_MODELS = [
+  {
+    id: 'gemini-3.8-flash',
+    name: 'Gemini 3.8 Flash High (Thinking)',
+    wireId: 'gemini-3.8-flash-high',
+    contextWindow: 1048576,
+    maxTokens: 65536,
+    supportsThinking: true,
+    thinkingBudget: 10000,
+    description: 'Google flagship coding model with 10k thinking budget (Fast & Deep)',
+  },
   {
     id: 'gemini-3.7-flash',
     name: 'Gemini 3.7 Flash High (Thinking)',