dsh-plugin-subscription-oauth 0.12.7 → 0.13.0

package/lib/providers/workbuddy.d.ts

@@ -63,6 +63,29 @@ export declare class WorkBuddyAdapter extends LlmAdapter {
     /** The stored session's fields as the token the request signs with. */
     private tokenOf;
     private requestBody;
+    /**
+     * Mend the tool schemas the way WorkBuddy's model gateway accepts.
+     *
+     * A tool name may hold only letters, digits, `_`, `-`; another character is refused, and
+     * a schema with a union at the parameter root or a `\0` escape is turned away by the
+     * model. Each unsafe name is made safe and the safe→original map kept on the adapter so
+     * the model's calls can be renamed back in the answer. Adapted from magpie's fitTools.
+     *
+     * @param tools - the declared tool schemas, when any.
+     * @returns the mended wire tools, or undefined when there are none.
+     */
+    private fittedTools;
+    /** The safe→original tool names to restore in the answer. */
+    private safeToolNames;
+    /** The assistant/tool history of the request being built, for renaming past calls. */
+    private historyMessages;
+    /**
+     * Restore the original tool names the model was given, in one parsed chunk.
+     *
+     * @param value - a decoded SSE payload.
+     * @returns whether any name changed.
+     */
+    private namedBack;
     /** The system prompt: the caller's, else WorkBuddy's default. */
     private systemPrompt;
     private toChatMessage;

package/lib/providers/workbuddy.js

@@ -8,7 +8,7 @@
  *
  * @module dsh-plugin-subscription-oauth/providers/workbuddy
  */
-import { LlmAdapter, errorChain, ReasoningEffortId, } from '@deepseek-ai/dsh-llm';
+import { LlmAdapter, errorChain, ReasoningEffortId, ToolCallId, } from '@deepseek-ai/dsh-llm';
 import { idleWatchdog, mapFetchFailure } from './common.js';
 import { proxiedFetch } from '../http.js';
 import { findEntry } from './catalog.js';
@@ -85,6 +85,121 @@ function randomHex() {
     crypto.getRandomValues(bytes);
     return [...bytes].map((byte) => byte.toString(16).padStart(2, '0')).join('');
 }
+/** A tool's name may hold letters, digits, `_`, `-`; another character is refused. */
+const NAME_OK = /^[A-Za-z0-9_-]+$/;
+/** A name with each character WorkBuddy refuses as `_`, kept apart from `taken`. */
+function safeName(name, taken) {
+    const base = name.replace(/[^A-Za-z0-9_-]/g, '_') || 'tool';
+    let candidate = base;
+    for (let index = 2; taken.has(candidate); index++)
+        candidate = `${base}_${index}`;
+    taken.add(candidate);
+    return candidate;
+}
+/** True for a plain object usable as a JSON-schema node. */
+function isSchemaRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+/**
+ * Mend a schema where the model gateway refuses one: `\0` escapes in a pattern, and an
+ * `items` list (deep models take a single shape or an anyOf, not a bare array).
+ */
+function fitSchema(schema, depth = 0) {
+    if (depth > 64)
+        return false;
+    let changed = false;
+    if (Array.isArray(schema)) {
+        for (const item of schema)
+            if (isSchemaRecord(item) && fitSchema(item, depth + 1))
+                changed = true;
+        return changed;
+    }
+    if (typeof schema.pattern === 'string' && schema.pattern.includes('\\0')) {
+        schema.pattern = schema.pattern.replace(/\\0/g, '\\u0000');
+        changed = true;
+    }
+    if (Array.isArray(schema.items)) {
+        const list = schema.items.filter(isSchemaRecord);
+        schema.items = list.length === 0 ? {} : list.length === 1 ? list[0] : { anyOf: list };
+        delete schema.additionalItems;
+        changed = true;
+    }
+    for (const value of Object.values(schema)) {
+        if (isSchemaRecord(value) && fitSchema(value, depth + 1))
+            changed = true;
+    }
+    return changed;
+}
+/** The schema a local `$ref` names, or `node` itself. */
+function localRef(root, node) {
+    const ref = node.$ref;
+    if (typeof ref !== 'string' || !ref.startsWith('#/'))
+        return node;
+    let at = root;
+    for (const key of ref.slice(2).split('/')) {
+        at = isSchemaRecord(at) ? at[key.replaceAll('~1', '/').replaceAll('~0', '~')] : undefined;
+    }
+    return isSchemaRecord(at) ? at : node;
+}
+/**
+ * Make a tool's parameters an object at the root, the shape every model takes: `allOf`'s
+ * branches are merged whole; of `anyOf`/`oneOf`'s object branches the properties are
+ * merged and a field each requires stays required.
+ */
+function objectRoot(node, root = node, depth = 0) {
+    const unions = ['allOf', 'anyOf', 'oneOf'].filter((key) => Array.isArray(node[key]));
+    if (node.type === 'object' && unions.length === 0)
+        return false;
+    const properties = isSchemaRecord(node.properties) ? { ...node.properties } : {};
+    const required = Array.isArray(node.required) ? [...node.required] : [];
+    for (const branch0 of Array.isArray(node.allOf) ? node.allOf : []) {
+        let branch = localRef(root, isSchemaRecord(branch0) ? branch0 : {});
+        if (unions.length > 0 && depth < 8)
+            objectRoot((branch = structuredClone(branch)), root, depth + 1);
+        if (isSchemaRecord(branch) && isSchemaRecord(branch.properties)) {
+            for (const [key, value] of Object.entries(branch.properties))
+                if (!(key in properties))
+                    properties[key] = value;
+        }
+        if (isSchemaRecord(branch) && Array.isArray(branch.required))
+            required.push(...branch.required);
+    }
+    const branches = [];
+    for (const key of ['anyOf', 'oneOf']) {
+        for (const branch0 of Array.isArray(node[key]) ? node[key] : []) {
+            let branch = localRef(root, isSchemaRecord(branch0) ? branch0 : {});
+            if (unions.length > 0 && depth < 8)
+                objectRoot((branch = structuredClone(branch)), root, depth + 1);
+            if (isSchemaRecord(branch) && (branch.type === 'object' || isSchemaRecord(branch.properties)))
+                branches.push(branch);
+        }
+    }
+    const from = new Map();
+    for (const branch of branches) {
+        if (!isSchemaRecord(branch.properties))
+            continue;
+        for (const [key, value] of Object.entries(branch.properties)) {
+            if (key in properties)
+                continue;
+            const seen = from.get(key) ?? [];
+            if (!seen.some((entry) => JSON.stringify(entry) === JSON.stringify(value)))
+                seen.push(value);
+            from.set(key, seen);
+        }
+    }
+    for (const [key, list] of from)
+        properties[key] = list.length === 1 ? list[0] : { anyOf: list };
+    delete node.allOf;
+    delete node.anyOf;
+    delete node.oneOf;
+    node.type = 'object';
+    node.properties = properties;
+    if (required.length > 0)
+        node.required = [...new Set(required)];
+    else
+        delete node.required;
+    return true;
+}
 /** The WorkBuddy China wire adapter serving the `workbuddy` route. */
 export class WorkBuddyAdapter extends LlmAdapter {
     options;
@@ -159,6 +274,9 @@ export class WorkBuddyAdapter extends LlmAdapter {
             throw new Error('WorkBuddy is not signed in');
         const token = this.tokenOf(held.session);
         const watchdog = idleWatchdog(options.signal, this.options.streamIdleTimeoutMs);
+        // Capture the tool-call history so unsafe tool names in past turns can be renamed to
+        // the safe ones the model now sees, keeping the conversation consistent.
+        this.historyMessages = options.messages.filter((message) => message.role === 'assistant' || message.role === 'tool');
         try {
             const body = this.requestBody(options);
             const response = await this.fetchFn(WORKBUDDY_API, {
@@ -167,10 +285,13 @@ export class WorkBuddyAdapter extends LlmAdapter {
                     'Content-Type': 'application/json',
                     'Accept': 'text/event-stream',
                     ...workbuddyHeaders(token),
-                    // Name the chat the way WorkBuddy's own client does: without these the gateway
-                    // counts the request under no client and can cut the stream.
+                    // Name the chat the way WorkBuddy's own client does: the conversation, the
+                    // turn, and the message. Without these the gateway counts the request under no
+                    // client and cuts the stream, which is why the reply stopped after a few seconds.
                     'X-Conversation-Message-ID': randomHex(),
                     'X-Request-ID': randomHex(),
+                    'X-Conversation-Request-ID': randomHex(),
+                    'X-Conversation-ID': randomHex(),
                 },
                 body: JSON.stringify(body),
                 signal: watchdog.signal,
@@ -212,13 +333,108 @@ export class WorkBuddyAdapter extends LlmAdapter {
         // Claude Code's own) out of every message — WorkBuddy reads them all, whatever role.
         const system = this.systemPrompt(options);
         messages.unshift({ role: 'system', content: system });
+        const tools = this.fittedTools(options.tools);
         return {
             model: options.model,
             messages: unflagMessages(messages),
+            ...tools === undefined ? {} : { tools: tools.tools },
             ...options.maxTokens === undefined ? {} : { max_tokens: options.maxTokens },
             stream: true,
         };
     }
+    /**
+     * Mend the tool schemas the way WorkBuddy's model gateway accepts.
+     *
+     * A tool name may hold only letters, digits, `_`, `-`; another character is refused, and
+     * a schema with a union at the parameter root or a `\0` escape is turned away by the
+     * model. Each unsafe name is made safe and the safe→original map kept on the adapter so
+     * the model's calls can be renamed back in the answer. Adapted from magpie's fitTools.
+     *
+     * @param tools - the declared tool schemas, when any.
+     * @returns the mended wire tools, or undefined when there are none.
+     */
+    fittedTools(tools) {
+        if (tools === undefined || tools.length === 0)
+            return undefined;
+        const wire = tools.map((tool) => ({
+            type: 'function',
+            function: {
+                name: tool.name,
+                ...tool.description === '' ? {} : { description: tool.description },
+                ...tool.parameters === undefined ? {} : { parameters: structuredClone(tool.parameters) },
+            },
+        }));
+        const taken = new Set();
+        for (const tool of wire) {
+            const name = tool.function.name;
+            if (typeof name === 'string' && NAME_OK.test(name))
+                taken.add(name);
+        }
+        const names = new Map();
+        const theirs = new Map();
+        for (const tool of wire) {
+            const fn = tool.function;
+            if (typeof fn.name === 'string' && !NAME_OK.test(fn.name)) {
+                const safe = safeName(fn.name, taken);
+                names.set(safe, fn.name);
+                theirs.set(fn.name, safe);
+                fn.name = safe;
+            }
+            if (fn.parameters !== undefined) {
+                if (!isSchemaRecord(fn.parameters))
+                    fn.parameters = { type: 'object', properties: {} };
+                else {
+                    fitSchema(fn.parameters);
+                    objectRoot(fn.parameters);
+                }
+            }
+        }
+        // Rename the calls in the conversation history to the safe names, so a turn that
+        // already called a tool matches the name the model now sees.
+        for (const message of this.historyMessages ?? []) {
+            for (const call of Array.isArray(message.tool_calls) ? message.tool_calls : []) {
+                const fn = call?.function;
+                if (fn && typeof fn.name === 'string' && theirs.has(fn.name))
+                    fn.name = theirs.get(fn.name);
+            }
+            if (message.role === 'tool' && typeof message.name === 'string' && theirs.has(message.name)) {
+                message.name = theirs.get(message.name);
+            }
+        }
+        this.safeToolNames = names;
+        return { tools: wire, names };
+    }
+    /** The safe→original tool names to restore in the answer. */
+    safeToolNames = new Map();
+    /** The assistant/tool history of the request being built, for renaming past calls. */
+    historyMessages = [];
+    /**
+     * Restore the original tool names the model was given, in one parsed chunk.
+     *
+     * @param value - a decoded SSE payload.
+     * @returns whether any name changed.
+     */
+    namedBack(value) {
+        let changed = false;
+        for (const choice of Array.isArray(value.choices) ? value.choices : []) {
+            if (!isSchemaRecord(choice))
+                continue;
+            for (const at of [choice.message, choice.delta]) {
+                if (!isSchemaRecord(at))
+                    continue;
+                for (const call of Array.isArray(at.tool_calls) ? at.tool_calls : []) {
+                    if (!isSchemaRecord(call) || !isSchemaRecord(call.function))
+                        continue;
+                    const original = this.safeToolNames.get(String(call.function.name));
+                    if (original !== undefined) {
+                        call.function.name = original;
+                        changed = true;
+                    }
+                }
+            }
+        }
+        return changed;
+    }
     /** The system prompt: the caller's, else WorkBuddy's default. */
     systemPrompt(options) {
         if (options.system !== undefined && options.system.trim() !== '')
@@ -299,6 +515,43 @@ export class WorkBuddyAdapter extends LlmAdapter {
                     catch {
                         continue;
                     }
+                    // WorkBuddy names a refusal mid-stream (an error frame, or a body with a non-zero
+                    // code): surface it instead of reading the rest as silence, so the turn fails with
+                    // the reason rather than stopping after a few empty seconds.
+                    const wireError = chunk.error ?? chunk.choices?.[0]?.delta;
+                    if (wireError !== undefined && wireError !== null && typeof wireError === 'object') {
+                        const message = wireError.message;
+                        if (typeof message === 'string' && message !== '')
+                            throw new Error(`WorkBuddy: ${message}`);
+                    }
+                    const wireCode = chunk.code;
+                    if (typeof wireCode === 'number' && wireCode !== 0) {
+                        const msg = chunk.msg;
+                        throw new Error(`WorkBuddy: ${typeof msg === 'string' ? msg : `error ${wireCode}`}`);
+                    }
+                    // Restore the tool names the model called to the ones the client declared, before
+                    // the chunk is read as a stream event.
+                    this.namedBack(chunk);
+                    // A tool-call delta: emit it so the harness can run the tool. The id and name ride
+                    // the first delta of each call; later deltas carry argument fragments.
+                    const toolCalls = chunk.choices?.[0]?.delta?.tool_calls;
+                    if (Array.isArray(toolCalls)) {
+                        for (const call of toolCalls) {
+                            const fn = call?.function;
+                            if (fn === undefined || fn === null)
+                                continue;
+                            const index = call.index ?? 0;
+                            const id = ToolCallId(call.id ?? `wb-tool-${index}`);
+                            const name = fn.name;
+                            const args = fn.arguments;
+                            if (typeof name === 'string' && name !== '') {
+                                yield { type: 'tool-call-delta', index, id, name, argumentsDelta: '' };
+                            }
+                            if (typeof args === 'string' && args !== '') {
+                                yield { type: 'tool-call-delta', index, id, argumentsDelta: args };
+                            }
+                        }
+                    }
                     const delta = chunk.choices?.[0]?.delta?.content;
                     if (typeof delta === 'string' && delta !== '') {
                         if (!started) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-plugin-subscription-oauth",
-  "version": "0.12.7",
+  "version": "0.13.0",
   "description": "Use subscription accounts as DeepSeek Harness LLM providers — Kimi Code (OAuth device flow), Grok / X Premium (OIDC + PKCE), Google Antigravity (Google OAuth + Cloud Code Assist) and GLM / BigModel (ZCode's browser sign-in) — with per-model visibility, drag-to-reorder Auto fallback and plan quotas from the web Settings page",
   "license": "MIT",
   "author": "EricFL1998",