dsh-plugin-subscription-oauth 0.12.8 → 0.15.0

package/lib/protocol.d.ts

@@ -12,7 +12,7 @@
 /** Prefix of every RPC method this plugin serves. */
 export declare const RPC_PREFIX = "subscription-oauth.";
 /** Endpoints the Settings page may call. */
-export declare const RPC_ENDPOINTS: readonly ["status", "login", "cancel", "logout", "setDefault", "refresh", "discover", "setModelVisible", "setModelOrder", "addModel", "removeModel", "usage", "reload", "auto-state", "setAutoOn", "deepseek-balance", "ccswitch-balance", "model-variants"];
+export declare const RPC_ENDPOINTS: readonly ["status", "login", "cancel", "logout", "setDefault", "refresh", "discover", "setModelVisible", "setModelOrder", "addModel", "removeModel", "usage", "reload", "auto-state", "setAutoOn", "checkin", "deepseek-balance", "ccswitch-balance", "model-variants"];
 /** One endpoint name. */
 export type RpcEndpoint = typeof RPC_ENDPOINTS[number];
 /** Client → host envelope. */
@@ -146,6 +146,13 @@ export interface ProviderUsage {
     renewsAt?: number;
     /** Metered allowances, most relevant first. */
     windows: readonly UsageWindow[];
+    /** Daily check-in state, when the provider states one. */
+    checkin?: {
+        active: boolean;
+        todayCheckedIn: boolean;
+        streakDays: number;
+        todayCredit: number;
+    };
     /** Epoch milliseconds these figures were read. */
     fetchedAt: number;
     /**
@@ -323,6 +330,10 @@ export interface RpcMap {
         payload: SetAutoOnRequest;
         value: AutoStateResult;
     };
+    checkin: {
+        payload: CheckinRequest;
+        value: CheckinResult;
+    };
     'deepseek-balance': {
         payload: DeepSeekBalanceRequest;
         value: DeepSeekBalanceResult;
@@ -398,6 +409,17 @@ export interface SetAutoOnRequest {
 export interface AutoStateResult {
     enabled: boolean;
 }
+/** Payload of `checkin`: which account claims today's reward. */
+export interface CheckinRequest {
+    provider: string;
+    account: string;
+}
+/** Result of `checkin`: the credit granted and the streak after claiming. */
+export interface CheckinResult {
+    credit: number;
+    streakDays: number;
+    already: boolean;
+}
 /** Payload of `deepseek-balance`. */
 export interface DeepSeekBalanceRequest {
     /** Client metadata the host's account service expects. */

package/lib/protocol.js

@@ -28,6 +28,7 @@ export const RPC_ENDPOINTS = [
     'reload',
     'auto-state',
     'setAutoOn',
+    'checkin',
     'deepseek-balance',
     'ccswitch-balance',
     'model-variants',

package/lib/providers/workbuddy-credits.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Per-account credit spend tracking for the WorkBuddy route.
+ *
+ * The gateway states the real billed figure for a turn — `usage.credit` on the last
+ * usage frame of the stream — so the spent total is a sum of those, never an estimate
+ * from tokens and a rate. Spends accumulate per account in a small JSON file beside the
+ * credentials, and fold with the live packages' remaining allowance into one precise
+ * spent-against-limit window.
+ *
+ * @module dsh-plugin-subscription-oauth/providers/workbuddy-credits
+ */
+/** One account's accumulated spend. */
+interface AccountSpend {
+    spent: number;
+    calls: number;
+}
+/** The spend ledger, keyed by account id. */
+export type SpendLedger = Record<string, AccountSpend>;
+/** Read the ledger, tolerating a missing or corrupt file. */
+export declare function readSpendLedger(file: string): Promise<SpendLedger>;
+/** Add one turn's billed credit to an account's spend, returning the new totals. */
+export declare function recordSpend(file: string, account: string, credit: number): Promise<AccountSpend>;
+export {};

package/lib/providers/workbuddy-credits.js

@@ -0,0 +1,52 @@
+/**
+ * Per-account credit spend tracking for the WorkBuddy route.
+ *
+ * The gateway states the real billed figure for a turn — `usage.credit` on the last
+ * usage frame of the stream — so the spent total is a sum of those, never an estimate
+ * from tokens and a rate. Spends accumulate per account in a small JSON file beside the
+ * credentials, and fold with the live packages' remaining allowance into one precise
+ * spent-against-limit window.
+ *
+ * @module dsh-plugin-subscription-oauth/providers/workbuddy-credits
+ */
+import { readFile, writeFile, mkdir } from 'node:fs/promises';
+import path from 'node:path';
+/** Read the ledger, tolerating a missing or corrupt file. */
+export async function readSpendLedger(file) {
+    try {
+        const raw = JSON.parse(await readFile(file, 'utf8'));
+        if (typeof raw !== 'object' || raw === null || Array.isArray(raw))
+            return {};
+        const out = {};
+        for (const [key, value] of Object.entries(raw)) {
+            if (typeof value !== 'object' || value === null)
+                continue;
+            const record = value;
+            const spent = typeof record.spent === 'number' && Number.isFinite(record.spent) ? record.spent : 0;
+            const calls = typeof record.calls === 'number' && Number.isFinite(record.calls) ? record.calls : 0;
+            out[key] = { spent: Math.max(0, spent), calls: Math.max(0, calls) };
+        }
+        return out;
+    }
+    catch {
+        return {};
+    }
+}
+/** Add one turn's billed credit to an account's spend, returning the new totals. */
+export async function recordSpend(file, account, credit) {
+    const ledger = await readSpendLedger(file);
+    const previous = ledger[account] ?? { spent: 0, calls: 0 };
+    const next = {
+        spent: Math.round((previous.spent + Math.max(0, credit)) * 10000) / 10000,
+        calls: previous.calls + 1,
+    };
+    ledger[account] = next;
+    try {
+        await mkdir(path.dirname(file), { recursive: true });
+        await writeFile(file, JSON.stringify(ledger, null, 2), 'utf8');
+    }
+    catch {
+        // A failed write keeps the in-memory figure; the next turn retries.
+    }
+    return next;
+}

package/lib/providers/workbuddy-provider.js

@@ -8,7 +8,9 @@ import { REAUTH_REQUIRED, ProviderError } from '../errors.js';
 import { TokenStore } from '../auth/store.js';
 import { TokenManager } from '../auth/tokens.js';
 import { LOGIN_CANCELLED_MESSAGE } from '../auth/device-flow.js';
-import { finishWorkBuddySignIn, parseWorkBuddySession, readWorkBuddyUsage, refreshWorkBuddyToken, startWorkBuddySignIn, workbuddyRefreshable, workbuddyStale, WORKBUDDY_EARLY_MS, } from '../auth/workbuddy-flow.js';
+import path from 'node:path';
+import { readSpendLedger } from './workbuddy-credits.js';
+import { finishWorkBuddySignIn, parseWorkBuddySession, readWorkBuddyUsage, refreshWorkBuddyToken, startWorkBuddySignIn, workbuddyRefreshable, workbuddyStale, claimWorkBuddyCheckin, WORKBUDDY_EARLY_MS, } from '../auth/workbuddy-flow.js';
 import { WorkBuddyAdapter, WORKBUDDY_CODE_URL, WORKBUDDY_CATALOG, WORKBUDDY_DEFAULT_MODEL, WORKBUDDY_PROVIDER_ID, WORKBUDDY_PROVIDER_NAME, } from './workbuddy.js';
 import { ProviderController } from '../auth/provider-controller.js';
 import { proxiedFetch } from '../http.js';
@@ -129,9 +131,11 @@ export function createWorkBuddyProvider(options) {
             }
         },
     });
+    const spendFile = path.join(path.dirname(options.credentialFile), 'workbuddy-spend.json');
     const adapter = new WorkBuddyAdapter({
         streamIdleTimeoutMs: options.streamIdleTimeoutMs,
         tokens,
+        spendFile,
         ...options.onWarn === undefined ? {} : { onWarn: options.onWarn },
         hiddenModels: () => options.preferences.hiddenIds(WORKBUDDY_PROVIDER_ID),
         userModels: () => options.preferences.extraIds(WORKBUDDY_PROVIDER_ID),
@@ -164,8 +168,10 @@ export function createWorkBuddyProvider(options) {
             const held = await store.get(account);
             if (held === undefined)
                 return undefined;
-            const read = await readWorkBuddyUsage(tokenOf(held), held.accountId, fetchFn);
-            return { plan: read.plan, windows: read.windows };
+            const ledger = await readSpendLedger(spendFile);
+            const spend = ledger[account];
+            const read = await readWorkBuddyUsage(tokenOf(held), held.accountId, fetchFn, spend === undefined ? undefined : { spent: spend.spent });
+            return { plan: read.plan, windows: read.windows, ...read.checkin === undefined ? {} : { checkin: read.checkin } };
         },
         details: () => [
             { key: 'provider', value: WORKBUDDY_PROVIDER_NAME },
@@ -201,5 +207,21 @@ export function createWorkBuddyProvider(options) {
         removeModel: (id) => controller.removeModel(id),
         usage: (force) => controller.usage(force),
         reload: () => controller.reload(),
+        checkin: async (account) => {
+            const held = await store.get(account);
+            if (held === undefined)
+                throw new ProviderError('WorkBuddy account not signed in', REAUTH_REQUIRED);
+            try {
+                const claim = await claimWorkBuddyCheckin(tokenOf(held), fetchFn);
+                return { credit: claim.credit, streakDays: claim.streakDays, already: claim.credit === 0 };
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                // An already-claimed check-in is a normal answer, not a failure.
+                if (/already|已签到/i.test(message))
+                    return { credit: 0, streakDays: 0, already: true };
+                throw new ProviderError(`WorkBuddy check-in failed: ${message}`, REAUTH_REQUIRED);
+            }
+        },
     };
 }

package/lib/providers/workbuddy.d.ts

@@ -43,6 +43,8 @@ export interface WorkBuddyAdapterOptions {
     onWarn?: (message: string) => void;
     hiddenModels?: () => Promise<ReadonlySet<string>>;
     userModels?: () => Promise<readonly string[]>;
+    /** Where per-account credit spends accumulate; beside the credential file. */
+    spendFile?: string;
     fetchFn?: FetchFn;
 }
 /** The WorkBuddy China wire adapter serving the `workbuddy` route. */
@@ -60,9 +62,34 @@ export declare class WorkBuddyAdapter extends LlmAdapter {
     resolveModel(_provider: string, model: string): Promise<LlmResolvedModelInfo>;
     providerRetryPolicy(): undefined;
     stream(options: GenerateOptions): AsyncIterable<StreamChunk>;
+    /** The current turn's billed credit, read off the last usage frame. */
+    private turnCredit;
     /** 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,11 +8,12 @@
  *
  * @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';
 import { WORKBUDDY_ENDPOINT, WORKBUDDY_UA_VERSION, workbuddyHeaders } from '../auth/workbuddy-flow.js';
+import { recordSpend } from './workbuddy-credits.js';
 /** The `workbuddy` provider route key (China build). */
 export const WORKBUDDY_PROVIDER_ID = 'workbuddy';
 /** Human name for the route and its cards. */
@@ -85,6 +86,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 +275,12 @@ 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');
+        // The last usage frame carries the turn's real billed credit; record it so the spend
+        // total is a sum of real figures, not an estimate.
+        this.turnCredit = 0;
         try {
             const body = this.requestBody(options);
             const response = await this.fetchFn(WORKBUDDY_API, {
@@ -190,8 +312,13 @@ export class WorkBuddyAdapter extends LlmAdapter {
         }
         finally {
             watchdog.stop();
+            if (this.turnCredit > 0 && this.options.spendFile !== undefined) {
+                void recordSpend(this.options.spendFile, held.account, this.turnCredit).catch(() => { });
+            }
         }
     }
+    /** The current turn's billed credit, read off the last usage frame. */
+    turnCredit = 0;
     /** The stored session's fields as the token the request signs with. */
     tokenOf(session) {
         return {
@@ -215,13 +342,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() !== '')
@@ -316,6 +538,29 @@ export class WorkBuddyAdapter extends LlmAdapter {
                         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) {
@@ -328,6 +573,11 @@ export class WorkBuddyAdapter extends LlmAdapter {
                     if (usage !== undefined && usage !== null) {
                         const input = usage.prompt_tokens ?? 0;
                         const output = usage.completion_tokens ?? 0;
+                        // The last usage frame carries the real billed credit; keep the latest, so a
+                        // mid-stream retry does not double-count.
+                        if (typeof usage.credit === 'number' && Number.isFinite(usage.credit)) {
+                            this.turnCredit = usage.credit;
+                        }
                         yield {
                             type: 'usage',
                             usage: { inputTokens: input, outputTokens: output, totalTokens: usage.total_tokens ?? input + output },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-plugin-subscription-oauth",
-  "version": "0.12.8",
+  "version": "0.15.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",