dsh-llm-adapters 1.2.0 → 1.2.2

package/src/trae.ts

@@ -1,8 +1,10 @@
 /**
- * Trae provider: model directory, SOLO chat and quota.
+ * Trae provider: model directory, SOLO chat, quota and client check-in.
  *
  * Trae's website login yields the same `Cloud-IDE-JWT` its own clients use, so
- * the plugin talks to the same gateways they do. Two catalog sources are merged:
+ * the plugin talks to the same gateways they do. A second sign-in method copies
+ * that token from the local desktop client; only that method carries the device
+ * id the daily check-in route accepts. Two catalog sources are merged:
  *
  *  - the Remote directory (`/api/remote/v1/models`) is the model skeleton —
  *    display name, context window, multiplier, reasoning options, multimodal;
@@ -44,9 +46,11 @@ import {
   TRAE_APP_ID, TRAE_REGION_PROFILES, TRAE_SOLO_CHAT_PATH, TRAE_SOLO_MODELS_PATH, TRAE_VERSION_CODE,
   TRAE_WEB_USER_AGENT,
 } from './trae-endpoints.ts'
+import { readTraeClientLogin } from './trae-client.ts'
+import type { TraeClientDetection } from './trae-client.ts'
 import { TraeWebLogin } from './trae-login.ts'
 import type { TraeLoginAccount } from './trae-login.ts'
-import type { QuotaPack, QuotaSnapshot } from './types.ts'
+import type { CheckinStatus, ClientLoginStatus, QuotaPack, QuotaSnapshot } from './types.ts'
 import { ProviderHttpError, buildMessages } from './wire.ts'
 import type { ReadImage, WireMessage } from './wire.ts'
 
@@ -181,6 +185,8 @@ export interface TraeProviderOptions {
   logger?: (message: string) => void
   /** The shared OpenRouter snapshot; a private one is created when omitted. */
   openRouter?: OpenRouterLookup
+  /** Overridable in tests; defaults to reading this machine's Trae client. */
+  clientLogin?: () => TraeClientDetection
 }
 
 function record(value: unknown): Record<string, unknown> | undefined {
@@ -895,6 +901,26 @@ export function parseTraeGlobalUsage(payload: unknown): QuotaSnapshot {
   }
 }
 
+/**
+ * The check-in body's `req_source`: 1 is the IDE, 2 is Trae Work. The desktop
+ * client sends 1; the claim route rejects the plugin's former empty body.
+ */
+export const TRAE_CHECKIN_REQ_SOURCE = 1
+
+export function parseTraeCheckin(payload: unknown): CheckinStatus {
+  const root = record(payload) ?? {}
+  // `extra_credits` is a campaign bonus the site does not add to the daily
+  // reward; summing it made the card promise 200 when the check-in pays 100.
+  const reward = num(root.credits) ?? 0
+  return {
+    available: root.enable !== false,
+    claimed: root.checked_in === true,
+    deviceClaimed: root.did_checked_in === true,
+    ...reward === 0 ? {} : { reward },
+    ...text(root.message) === undefined ? {} : { message: text(root.message)! },
+  }
+}
+
 export class TraeProvider {
   private catalogInstance: ModelCatalog
   private catalogRegion: TraeRegion
@@ -1142,6 +1168,167 @@ export class TraeProvider {
     return this.quotaInflight
   }
 
+  /**
+   * The second sign-in method: the desktop client's current state.
+   *
+   * Read-only; the settings page only receives the non-secret status, never
+   * the token.
+   */
+  async localClientLogin(): Promise<ClientLoginStatus> {
+    return this.readClientLogin().status
+  }
+
+  private readClientLogin(): TraeClientDetection {
+    return (this.options.clientLogin ?? (() => readTraeClientLogin(this.options.region())))()
+  }
+
+  /** Import the desktop client's token, device id and machine id. */
+  async importClientLogin(): Promise<void> {
+    const region = this.ensureRegion()
+    const detection = this.readClientLogin()
+    if (!detection.status.available) {
+      throw new Error('本机没有检测到 Trae 客户端。请先安装并登录客户端，或改用网页登录。')
+    }
+    const state = detection.state
+    if (!detection.status.signedIn || state === undefined) {
+      throw new Error(detection.status.error ?? '本机 Trae 客户端尚未登录。请先在客户端完成登录。')
+    }
+    // A browser flow that is still running would save its own account after
+    // this import, so cancel it before replacing the record.
+    await this.loginFlow?.cancel()
+    await this.options.store.saveTrae({
+      accessToken: state.token,
+      region,
+      source: 'client',
+      deviceId: state.deviceId,
+      machineId: state.machineId,
+      loginAt: Date.now(),
+      ...state.userId === undefined ? {} : { userId: state.userId },
+      ...state.name === undefined ? {} : { name: state.name },
+      ...state.expiresAt === undefined ? {} : { expiresAt: state.expiresAt },
+    })
+    this.invalidateModels()
+    this.invalidateQuota()
+  }
+
+  private async checkinContext(): Promise<
+    | { ok: true, profile: TraeRegionProfile, token: string, identity: { deviceId: string, machineId: string } }
+    | { ok: false, status: CheckinStatus }
+  > {
+    this.ensureRegion()
+    const profile = this.profile()
+    if (!profile.checkin) {
+      return {
+        ok: false,
+        status: {
+          available: false, claimed: false, deviceClaimed: false,
+          message: 'Trae 国际版没有签到活动。',
+        },
+      }
+    }
+    const auth = await this.options.auth.status()
+    if (!auth.signedIn) {
+      return {
+        ok: false,
+        status: {
+          available: false, claimed: false, deviceClaimed: false,
+          message: auth.error ?? '尚未登录，无法签到。',
+        },
+      }
+    }
+    if (auth.loginSource !== 'client') {
+      return {
+        ok: false,
+        status: {
+          available: false, claimed: false, deviceClaimed: false,
+          message: '签到仅在复用本机 Trae 客户端登录时可用；网页登录没有客户端设备号。',
+        },
+      }
+    }
+    let token: string
+    let identity: { deviceId: string, machineId: string }
+    try {
+      token = await this.options.auth.accessToken()
+      identity = await this.options.auth.identity()
+    } catch (error) {
+      return {
+        ok: false,
+        status: {
+          available: false, claimed: false, deviceClaimed: false,
+          message: error instanceof Error ? error.message : String(error),
+        },
+      }
+    }
+    if (!/^\d{16}$/.test(identity.deviceId)) {
+      return {
+        ok: false,
+        status: {
+          available: false, claimed: false, deviceClaimed: false,
+          message: '本机 Trae 客户端登录缺少 16 位设备号，请先在客户端重新登录后再复用。',
+        },
+      }
+    }
+    return {
+      ok: true,
+      profile,
+      token,
+      identity: { deviceId: identity.deviceId, machineId: identity.machineId },
+    }
+  }
+
+  async checkinStatus(): Promise<CheckinStatus> {
+    const context = await this.checkinContext()
+    if (!context.ok) return context.status
+    const response = await this.fetchImpl(`${context.profile.apiBase}/trae/api/v2/ug/checkin_credits/status`, {
+      method: 'POST',
+      headers: {
+        ...this.headers(context.token, context.profile),
+        'x-user-region': 'CN',
+        'x-device-id': context.identity.deviceId,
+        'x-machine-id': context.identity.machineId,
+      },
+      body: JSON.stringify({ req_source: TRAE_CHECKIN_REQ_SOURCE }),
+      signal: AbortSignal.timeout(this.options.timeoutMs()),
+    })
+    if (!response.ok) throw new ProviderHttpError(await responseError(response), response.status)
+    return parseTraeCheckin(await response.json())
+  }
+
+  /** Claim today's reward. The only state-changing call in this provider. */
+  async claimCheckin(): Promise<CheckinStatus> {
+    const context = await this.checkinContext()
+    if (!context.ok) throw new Error(context.status.message ?? '当前登录方式不能签到。')
+    const response = await this.fetchImpl(`${context.profile.apiBase}/trae/api/v2/ug/checkin_credits/claim`, {
+      method: 'POST',
+      headers: {
+        ...this.headers(context.token, context.profile),
+        'x-user-region': 'CN',
+        'x-device-id': context.identity.deviceId,
+        'x-machine-id': context.identity.machineId,
+      },
+      body: JSON.stringify({ req_source: TRAE_CHECKIN_REQ_SOURCE }),
+      signal: AbortSignal.timeout(this.options.timeoutMs()),
+    })
+    if (!response.ok) throw new ProviderHttpError(await responseError(response), response.status)
+    const payload = record(await response.json()) ?? {}
+    const code = typeof payload.code === 'number' ? payload.code : 0
+    if (code === 0) {
+      this.invalidateQuota()
+      const reward = num(payload.credits)
+      return {
+        available: true,
+        claimed: true,
+        deviceClaimed: false,
+        ...reward === undefined || reward === 0 ? {} : { reward },
+        ...text(payload.message) === undefined ? {} : { message: text(payload.message)! },
+      }
+    }
+    if (code === 9095) {
+      return { available: true, claimed: false, deviceClaimed: true, message: '本机今日已签到' }
+    }
+    throw new Error(text(payload.message) ?? `签到失败（code ${code}）`)
+  }
+
   async *stream(
     options: GenerateOptions,
     model: string,
@@ -1218,6 +1405,7 @@ export class TraeProvider {
         await this.options.store.saveTrae({
           accessToken: account.accessToken,
           region: target,
+          source: 'web',
           deviceId: account.deviceId,
           machineId: account.machineId,
           loginAt: Date.now(),

package/src/types.ts

@@ -58,6 +58,23 @@ export interface CheckinStatus {
   url?: string
 }
 
+/**
+ * The local Trae client's state, as shown on the settings page.
+ *
+ * Never carries the token: only whether the client was found, whether a usable
+ * login was read, and the non-secret account fields.
+ */
+export interface ClientLoginStatus {
+  /** A Trae client data directory exists on this machine. */
+  available: boolean
+  /** The stored login is present, unexpired and usable. */
+  signedIn: boolean
+  name?: string
+  userId?: string
+  expiresAt?: number
+  error?: string
+}
+
 export interface ProviderStatus extends AuthStatus {
   brand: BrandId
   /** Trae only: the region this reading belongs to. */
@@ -65,7 +82,9 @@ export interface ProviderStatus extends AuthStatus {
   /** Present only after a successful quota read. */
   quota?: QuotaSnapshot
   quotaError?: string
-  /** Trae CN only. */
+  /** Trae only: the second sign-in method, when the desktop client exists. */
+  clientLogin?: ClientLoginStatus
+  /** Trae CN only, and only for a login imported from the client. */
   checkin?: CheckinStatus
 }
 

package/lib/types/codearts-window.d.ts

@@ -1,65 +0,0 @@
-/**
- * The trial plan's chat budget.
- *
- * The gateway opens one "session" per chat request and allows **three per
- * rolling minute** for the whole account. The window is shared by every model,
- * it is not keyed by `session-id` (re-sending the same id does not buy a slot),
- * and a request rejected with `InferHub.4004.200` spends a slot just like a
- * successful one. Measured behaviour, three slots then a lockout:
- *
- * ```
- * t+0s   ok ok ok cap cap cap     burst of six
- * t+10s  cap                      …
- * t+51s  cap
- * t+61s  ok ok ok                 the burst ages out of the window
- * ```
- *
- * So a turn cannot be made to "go faster" by retrying: the only way a request
- * stops failing is to spend the budget deliberately — wait for the oldest start
- * to age out instead of firing into a wall. This class owns that bookkeeping and
- * is shared by every provider instance in the process, because a hot reload
- * must not reset the count the gateway still remembers.
- *
- * @module dsh-llm-adapters/codearts-window
- */
-/** Sessions the trial plan allows inside one window. */
-export declare const CODEARTS_SESSION_LIMIT = 3;
-/** How long a start keeps its slot. Measured: the burst frees at ~60 s. */
-export declare const CODEARTS_SESSION_WINDOW_MS = 60000;
-/** The claim a caller holds while its request is in flight. */
-export interface CodeArtsSessionSlot {
-    /**
-     * Give the slot back.
-     *
-     * The gateway does not charge for a call it turned away: a burst rejected
-     * with `TM.00001041` at t+0 s lifts at the same moment as one that was never
-     * sent. Keeping the slot after a refusal would therefore throttle the next
-     * minute to one request per twenty seconds for no reason.
-     */
-    release(): void;
-}
-export declare class CodeArtsSessionWindow {
-    private readonly limit;
-    private readonly windowMs;
-    private readonly now;
-    private readonly starts;
-    /** Serialises waiters so two callers cannot both take the last slot. */
-    private tail;
-    constructor(limit?: number, windowMs?: number, now?: () => number);
-    /** Starts recorded inside the current window. */
-    get size(): number;
-    /** Milliseconds until another start fits; `0` when the window has room. */
-    waitMs(): number;
-    /**
-     * Claim a slot, waiting for the window to roll over when it is full.
-     *
-     * The slot is recorded on return, not on completion: the gateway counts the
-     * start, and holds it for a fixed time whether the answer was short or long.
-     */
-    open(signal?: AbortSignal): Promise<CodeArtsSessionSlot>;
-    /** Forget every start (tests, and a fresh login on another account). */
-    reset(): void;
-    private trim;
-}
-/** The process-wide window; a plugin reload reuses it on purpose. */
-export declare function sharedSessionWindow(): CodeArtsSessionWindow;

package/src/codearts-window.ts

@@ -1,136 +0,0 @@
-/**
- * The trial plan's chat budget.
- *
- * The gateway opens one "session" per chat request and allows **three per
- * rolling minute** for the whole account. The window is shared by every model,
- * it is not keyed by `session-id` (re-sending the same id does not buy a slot),
- * and a request rejected with `InferHub.4004.200` spends a slot just like a
- * successful one. Measured behaviour, three slots then a lockout:
- *
- * ```
- * t+0s   ok ok ok cap cap cap     burst of six
- * t+10s  cap                      …
- * t+51s  cap
- * t+61s  ok ok ok                 the burst ages out of the window
- * ```
- *
- * So a turn cannot be made to "go faster" by retrying: the only way a request
- * stops failing is to spend the budget deliberately — wait for the oldest start
- * to age out instead of firing into a wall. This class owns that bookkeeping and
- * is shared by every provider instance in the process, because a hot reload
- * must not reset the count the gateway still remembers.
- *
- * @module dsh-llm-adapters/codearts-window
- */
-
-/** Sessions the trial plan allows inside one window. */
-export const CODEARTS_SESSION_LIMIT = 3
-
-/** How long a start keeps its slot. Measured: the burst frees at ~60 s. */
-export const CODEARTS_SESSION_WINDOW_MS = 60_000
-
-/** A little slack so a request never lands a few milliseconds early. */
-const MARGIN_MS = 1_500
-
-/** The claim a caller holds while its request is in flight. */
-export interface CodeArtsSessionSlot {
-  /**
-   * Give the slot back.
-   *
-   * The gateway does not charge for a call it turned away: a burst rejected
-   * with `TM.00001041` at t+0 s lifts at the same moment as one that was never
-   * sent. Keeping the slot after a refusal would therefore throttle the next
-   * minute to one request per twenty seconds for no reason.
-   */
-  release(): void
-}
-
-function sleep(ms: number, signal?: AbortSignal): Promise<void> {
-  return new Promise((resolve, reject) => {
-    if (signal?.aborted === true) {
-      reject(signal.reason instanceof Error ? signal.reason : new Error('aborted'))
-      return
-    }
-    const onAbort = (): void => {
-      clearTimeout(timer)
-      reject(signal?.reason instanceof Error ? signal.reason : new Error('aborted'))
-    }
-    const timer = setTimeout(() => {
-      signal?.removeEventListener('abort', onAbort)
-      resolve()
-    }, ms)
-    signal?.addEventListener('abort', onAbort, { once: true })
-  })
-}
-
-export class CodeArtsSessionWindow {
-  private readonly starts: number[] = []
-  /** Serialises waiters so two callers cannot both take the last slot. */
-  private tail: Promise<void> = Promise.resolve()
-
-  constructor(
-    private readonly limit: number = CODEARTS_SESSION_LIMIT,
-    private readonly windowMs: number = CODEARTS_SESSION_WINDOW_MS,
-    private readonly now: () => number = Date.now,
-  ) {}
-
-  /** Starts recorded inside the current window. */
-  get size(): number {
-    this.trim()
-    return this.starts.length
-  }
-
-  /** Milliseconds until another start fits; `0` when the window has room. */
-  waitMs(): number {
-    this.trim()
-    if (this.starts.length < this.limit) return 0
-    const oldest = this.starts[0] ?? 0
-    return Math.max(0, this.windowMs - (this.now() - oldest))
-  }
-
-  /**
-   * Claim a slot, waiting for the window to roll over when it is full.
-   *
-   * The slot is recorded on return, not on completion: the gateway counts the
-   * start, and holds it for a fixed time whether the answer was short or long.
-   */
-  async open(signal?: AbortSignal): Promise<CodeArtsSessionSlot> {
-    const run = this.tail.then(async (): Promise<CodeArtsSessionSlot> => {
-      for (;;) {
-        const wait = this.waitMs()
-        if (wait === 0) {
-          const start = this.now()
-          this.starts.push(start)
-          return {
-            release: () => {
-              const index = this.starts.indexOf(start)
-              if (index >= 0) this.starts.splice(index, 1)
-            },
-          }
-        }
-        await sleep(wait + MARGIN_MS, signal)
-      }
-    })
-    // A failed waiter must not poison the queue for the next one.
-    this.tail = run.then(() => undefined, () => undefined)
-    return await run
-  }
-
-  /** Forget every start (tests, and a fresh login on another account). */
-  reset(): void {
-    this.starts.length = 0
-  }
-
-  private trim(): void {
-    const now = this.now()
-    while (this.starts.length > 0 && now - (this.starts[0] ?? 0) >= this.windowMs) this.starts.shift()
-  }
-}
-
-let shared: CodeArtsSessionWindow | undefined
-
-/** The process-wide window; a plugin reload reuses it on purpose. */
-export function sharedSessionWindow(): CodeArtsSessionWindow {
-  shared ??= new CodeArtsSessionWindow()
-  return shared
-}