@ngotrnghia1811/opencode-windsurf-auth 0.1.1 → 0.1.2

package/dist/chat-request.d.ts

@@ -19,6 +19,7 @@ export interface GetChatMessageInput {
         parametersJsonSchema: string;
     }>;
     modelId: string;
+    maxOutputTokens: number;
     sessionId?: string;
 }
 export declare function encodeGetChatMessageRequest(input: GetChatMessageInput): Uint8Array;

package/dist/chat-request.js

@@ -68,10 +68,10 @@ function encodeTool(name, description, parametersJsonSchema) {
     return concat(encodeStringField(1, name), encodeStringField(2, description), encodeStringField(3, parametersJsonSchema));
 }
 /** Build the model_params sub-message (f8). */
-function encodeModelParams() {
+function encodeModelParams(maxOutputTokens) {
     return concat(encodeVarintField(1, 1), // f1: unk1 (=1)
     encodeVarintField(2, 128000), // f2: max_context_tokens
-    encodeVarintField(3, 400), // f3: max_output_tokens
+    encodeVarintField(3, maxOutputTokens), // f3: max_output_tokens
     encodeFixed64Field(5, 1.0), // f5: temperature
     encodeVarintField(7, 40), // f7: top_k
     encodeFixed64Field(8, 0.95));
@@ -103,7 +103,7 @@ export function encodeGetChatMessageRequest(input) {
     // f7: unk7 = 5
     encodeVarintField(7, 5), 
     // f8: model_params
-    encodeMessageField(8, encodeModelParams()), 
+    encodeMessageField(8, encodeModelParams(input.maxOutputTokens)), 
     // f10: tools[] (repeated)
     ...input.tools.map((t) => encodeMessageField(10, encodeTool(t.name, t.description, t.parametersJsonSchema))), 
     // f15: unk15

package/dist/models.js

@@ -27,7 +27,7 @@ const BASE_MODEL = {
     },
     limit: {
         context: 128_000,
-        output: 8_192,
+        output: 32_000,
     },
     status: "active",
     options: {},

package/dist/windsurf-provider.js

@@ -186,19 +186,83 @@ async function streamViaDirectConnect(controller, options, modelId, tracker, sig
         messages,
         tools,
         modelId,
+        maxOutputTokens: options.maxOutputTokens ?? 4096,
     });
     let reasoningStarted = false;
     let textStarted = false;
     let finished = false;
     const toolCalls = new Map();
     let toolCallStarted = false;
+    // Build lookup from tool name → JSON Schema properties for coercion.
+    // Windsurf models sometimes emit nested JSON arrays/objects as JSON-encoded
+    // strings rather than native values (e.g. {"questions": "[...]"}), which
+    // causes downstream Zod validation to fail.  This map lets flushToolCall
+    // un-wrap those values transparently.
+    const toolSchemaMap = new Map();
+    for (const t of options.tools ?? []) {
+        if (t.type !== "function")
+            continue;
+        const ft = t;
+        const schema = ft.inputSchema;
+        const props = schema?.properties;
+        if (props && typeof props === "object" && !Array.isArray(props)) {
+            toolSchemaMap.set(ft.name, props);
+        }
+    }
     const events = streamGetChatMessage(body, signal);
     function flushToolCall(id) {
         const tc = toolCalls.get(id);
         if (!tc)
             return;
         toolCalls.delete(id);
-        const input = tc.argsChunks.join("");
+        const rawInput = tc.argsChunks.join("");
+        let input = rawInput;
+        try {
+            const parsed = JSON.parse(rawInput);
+            if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+                const props = toolSchemaMap.get(tc.name);
+                if (props) {
+                    let modified = false;
+                    for (const key of Object.keys(props)) {
+                        const value = parsed[key];
+                        if (typeof value !== "string")
+                            continue;
+                        const schemaType = props[key].type;
+                        if (!schemaType)
+                            continue;
+                        const wantsArray = schemaType === "array" ||
+                            (Array.isArray(schemaType) && schemaType.includes("array"));
+                        const wantsObject = schemaType === "object" ||
+                            (Array.isArray(schemaType) && schemaType.includes("object"));
+                        if (!wantsArray && !wantsObject)
+                            continue;
+                        try {
+                            const inner = JSON.parse(value);
+                            if (wantsArray && Array.isArray(inner)) {
+                                parsed[key] = inner;
+                                modified = true;
+                            }
+                            else if (wantsObject &&
+                                inner !== null &&
+                                typeof inner === "object" &&
+                                !Array.isArray(inner)) {
+                                parsed[key] = inner;
+                                modified = true;
+                            }
+                        }
+                        catch {
+                            // inner parse failed — leave original string value
+                        }
+                    }
+                    if (modified) {
+                        input = JSON.stringify(parsed);
+                    }
+                }
+            }
+        }
+        catch {
+            // outer parse failed — emit raw joined string unchanged
+        }
         controller.enqueue({ type: "tool-input-end", id });
         controller.enqueue({ type: "tool-call", toolCallId: id, toolName: tc.name, input });
         trackContent(tracker, "tool-call");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ngotrnghia1811/opencode-windsurf-auth",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "type": "module",
   "publishConfig": {
     "access": "public"