dsh-connect-trae 1.0.0

package/lib/index.d.ts

@@ -0,0 +1,975 @@
+import z from "@deepseek-ai/schemastery";
+import { PiAiAdapter } from "@deepseek-ai/dsh-llm-pi-ai";
+import { Context } from "@deepseek-ai/cordis";
+import { AttachmentStore } from "@deepseek-ai/dsh-attachment";
+//#region src/reasoning.d.ts
+declare const TRAE_REASONING_EFFORTS: readonly ["minimal", "low", "medium", "high", "xhigh"];
+type TraeReasoningEffort = typeof TRAE_REASONING_EFFORTS[number];
+interface TraeReasoningCapability {
+  supported: readonly TraeReasoningEffort[];
+  defaultEffort?: TraeReasoningEffort;
+}
+declare function parseReasoningCapability(value: unknown): TraeReasoningCapability | undefined;
+/** Add effort only when the selected model advertises that exact value. */
+declare function applyReasoningEffort<T extends Record<string, unknown>>(body: T, effort: TraeReasoningEffort | undefined, capability: TraeReasoningCapability | undefined): T & {
+  reasoning_effort?: TraeReasoningEffort;
+};
+//#endregion
+//#region src/model-metadata.d.ts
+interface TraeDiscoveredReasoning {
+  supported: TraeReasoningEffort[];
+  defaultEffort?: TraeReasoningEffort;
+}
+interface TraeDiscoveredModel {
+  id: string;
+  name: string;
+  multimodal: boolean;
+  contextWindow?: number;
+  maxContextWindow?: number;
+  creditMultiplier?: number;
+  reasoningSupported: boolean;
+  reasoning?: TraeDiscoveredReasoning;
+}
+/** Parse only capabilities explicitly advertised by Trae's remote model API. */
+declare function parseTraeRemoteModel(value: unknown): TraeDiscoveredModel | undefined;
+//#endregion
+//#region src/catalog.d.ts
+interface TraeModelInfo {
+  id: string;
+  name: string;
+  contextWindow?: number;
+  maxTokens?: number;
+  input?: ('text' | 'image')[];
+  creditMultiplier?: number;
+  reasoningSupported?: boolean;
+  reasoning?: TraeDiscoveredReasoning;
+  reasoningEfforts?: Partial<Record<TraeReasoningEffort, string | null>>;
+  baseModelId?: string;
+  maxContext?: boolean;
+  maxContextWindow?: number;
+}
+/** Bootstrap catalog: identity only where current Trae metadata has not been fetched yet. */
+declare const FALLBACK_TRAE_MODELS: readonly TraeModelInfo[];
+/** Convert verified Trae API metadata into normal models and optional 1M variants. */
+declare function discoveredCatalog(models: readonly TraeDiscoveredModel[], enabled1m?: ReadonlySet<string>): TraeModelInfo[];
+declare class TraeCatalog {
+  private models;
+  current(): readonly TraeModelInfo[];
+  set(models: readonly TraeModelInfo[]): void;
+}
+//#endregion
+//#region src/upstream.d.ts
+type TraeUpstreamErrorKind = 'authentication' | 'hard_credit' | 'soft_rate' | 'not_found' | 'server' | 'client' | 'unconfigured';
+type TraeChatResult = {
+  ok: true;
+  response: Response;
+} | {
+  ok: false;
+  status: number;
+  kind: TraeUpstreamErrorKind;
+  message: string;
+};
+interface TraeUpstreamClient {
+  chatStream(bodyJson: string, signal?: AbortSignal): Promise<TraeChatResult>;
+}
+/**
+ * Safe first-stage upstream. Real Trae traffic stays disabled until one
+ * edition-specific endpoint and wire codec are verified with fixtures.
+ */
+declare class UnconfiguredTraeUpstreamClient implements TraeUpstreamClient {
+  chatStream(_bodyJson: string, _signal?: AbortSignal): Promise<TraeChatResult>;
+}
+//#endregion
+//#region src/shim.d.ts
+interface ShimLogger {
+  warn(...args: unknown[]): void;
+  error(...args: unknown[]): void;
+}
+interface TraeShim {
+  ready: Promise<void>;
+  baseUrl(): string;
+  token(): string;
+  close(): Promise<void>;
+}
+interface TraeShimOptions {
+  catalog: TraeCatalog;
+  client: TraeUpstreamClient;
+  logger?: ShimLogger;
+}
+declare function createTraeShim(options: TraeShimOptions): TraeShim;
+//#endregion
+//#region src/adapter.d.ts
+declare const TRAE_PROVIDER = "trae";
+declare const TRAE_STREAM_IDLE_TIMEOUT_MS = 300000;
+interface TraeAdapterOptions {
+  shim: TraeShim;
+  catalog: TraeCatalog;
+  resolveAttachments?: () => AttachmentStore | undefined;
+}
+interface TraeAdapter {
+  adapter: PiAiAdapter;
+  invalidate(): void;
+}
+declare function createTraeAdapter(options: TraeAdapterOptions): TraeAdapter;
+//#endregion
+//#region src/paths.d.ts
+type TraeEdition = 'cn' | 'sg' | 'solo' | 'solo-sg';
+interface TraeStorageCandidate {
+  edition: TraeEdition;
+  path: string;
+}
+declare function traeStorageCandidates(platform?: NodeJS.Platform, home?: string, env?: NodeJS.ProcessEnv): TraeStorageCandidate[];
+//#endregion
+//#region src/auth.d.ts
+interface TraeCredential {
+  accessToken: string;
+  refreshToken?: string;
+  userId: string;
+  accountName?: string;
+  host: string;
+  expiresAtMs: number;
+  refreshExpiresAtMs?: number;
+  edition: TraeEdition;
+  source: 'desktop' | 'dsh';
+}
+interface TraeRefreshOutcome {
+  accessToken: string;
+  refreshToken?: string;
+  expiresAtMs: number;
+  refreshExpiresAtMs?: number;
+  host?: string;
+}
+interface TraeCredentialStoreOptions {
+  storagePath?: string;
+  edition?: TraeEdition | 'auto';
+  accountId?: string;
+  ownPath?: string;
+  refresh: (credential: TraeCredential) => Promise<TraeRefreshOutcome>;
+  refreshMarginMs?: number;
+}
+interface TraeAccountChoice {
+  id: string;
+  accountName: string;
+  edition: TraeEdition;
+  source: 'desktop' | 'dsh';
+  tokenExpiresAtMs: number;
+  selected: boolean;
+}
+declare function traeOwnAuthPath(): string;
+declare function normalizeTraeCredential(raw: unknown, edition: TraeEdition, source: TraeCredential['source']): TraeCredential | undefined;
+declare class TraeCredentialStore {
+  private storagePathOverride;
+  private edition;
+  private accountId;
+  private preferIds;
+  private readonly ownPath;
+  private readonly refresh;
+  private readonly refreshMarginMs;
+  private inflight;
+  constructor(options: TraeCredentialStoreOptions);
+  setSource(storagePath: string | undefined, edition?: TraeEdition | 'auto', accountId?: string): void;
+  selectAccount(accountId: string | undefined): void;
+  /**
+   * Preferred account ordering used when no account is explicitly selected.
+   * The connector can only bill the `llm_utils_chat` channel against general
+   * credits, so accounts with zero general credits should not become the
+   * default or they fail with 4008 / empty responses.
+   */
+  setPreferAccountIds(ids: readonly string[]): void;
+  candidates(): TraeStorageCandidate[];
+  /** First credential matching the preferred ordering, else the first live one. */
+  private preferred;
+  accounts(): Promise<TraeAccountChoice[]>;
+  current(): Promise<TraeCredential | undefined>;
+  resolve(): Promise<TraeCredential>;
+  status(): Promise<{
+    state: 'signed-in' | 'signed-out';
+    edition?: TraeEdition;
+    expiresAtMs?: number;
+    source?: 'desktop' | 'dsh';
+  }>;
+  desktopFilePresent(): Promise<boolean>;
+  logout(): Promise<void>;
+  private readAll;
+  private readDesktopAll;
+  private readOwn;
+  private refreshNow;
+}
+//#endregion
+//#region src/decrypt.d.ts
+declare function decryptTraeStorageValue(encoded: string): string;
+declare function parseTraeAuthValue(value: string): unknown;
+declare function parseTraeStorageDocument(text: string): unknown;
+//#endregion
+//#region src/identity.d.ts
+interface TraeIdentity {
+  edition: TraeEdition;
+  machineId: string;
+  deviceId: string;
+  appVersion?: string;
+  buildVersion?: string;
+  deviceBrand?: string;
+  deviceCpu?: string;
+  osVersion?: string;
+  platform: NodeJS.Platform;
+}
+/** Read stable identity from Trae-owned files without generating impersonated IDs. */
+declare function readTraeIdentity(candidate: TraeStorageCandidate): Promise<TraeIdentity>;
+/** Headers derived from actual persisted identity, never a new random identity per request. */
+declare function identityHeaders(identity: TraeIdentity): Record<string, string>;
+//#endregion
+//#region src/model-config.d.ts
+interface TraeObservedModelConfig {
+  configName: string;
+  modelName: string;
+  promptSet?: string;
+  abVersion?: string;
+  rawChatFunction?: string;
+}
+/**
+ * Parse a secret-free CustomModel debug line emitted by Trae. Optional values
+ * remain absent when Trae prints None; we must not invent defaults for them.
+ */
+declare function parseObservedModelConfig(line: string): TraeObservedModelConfig | undefined;
+//#endregion
+//#region src/model-cache.d.ts
+interface TraeCachedModelConfig {
+  name: string;
+  customConfig?: Record<string, unknown>;
+  promptMaxTokens?: number;
+  maxTokens?: number;
+  maxTurn?: number;
+  multimodal?: boolean;
+  modelType?: string;
+}
+/** Parse a safe subset of one cached model entry; credentials and endpoints are intentionally omitted. */
+declare function parseTraeCachedModel(value: unknown): TraeCachedModelConfig | undefined;
+/** Read Trae's own current user's model map via sqlite3 without exposing secrets. */
+declare function readTraeCachedModel(functionName: string, modelName: string, userId: string): Promise<TraeCachedModelConfig | undefined>;
+//#endregion
+//#region src/model-extra-config.d.ts
+interface TraeRawChatBehaviorConfig {
+  passBackReasoning?: boolean;
+  nativeFunctionCall?: boolean;
+  useV2Process?: boolean;
+  maxModeEnabled?: boolean;
+  maxToolcallChars?: number;
+  streamThrottleEnabled?: boolean;
+}
+/** Parse only Raw Chat behavior switches observed in Trae's model_extra_config. */
+declare function parseTraeRawChatBehaviorConfig(value: unknown): TraeRawChatBehaviorConfig;
+/** Extract the JSON object from one native model_extra_config parse log line. */
+declare function parseTraeModelExtraConfigLogLine(line: string): TraeRawChatBehaviorConfig | undefined;
+//#endregion
+//#region src/model-detail.d.ts
+declare const TRAE_MODEL_DETAIL_PATH = "/api/ide/v1/batch_get_detail_param";
+declare const TRAE_MODEL_DETAIL_FUNCTIONS: readonly ["ui_builder_v2", "solo_coder", "chat_v3", "solo_builder", "builder_v3", "builder", "chat", "inline_chat", "git_ai", "custom_agent_generation", "utils", "code_reviewer", "code_review_summary", "solo_agent", "solo_agent_remote", "solo_work_remote", "solo_agent_lite", "solo_work_lite", "solo_design_lite", "solo_design_remote", "multimodal", "system_diagnosis"];
+interface TraeModelDetailRequest {
+  functions: string[];
+  agent_type: '' | 'solo_agent';
+  current_config_info: {
+    config_name: string;
+    is_custom_model: boolean;
+  };
+  mode_type: 0;
+  access_type: 0;
+  ab_force_vids: '';
+  ab_autotest_advanced_mode: 0;
+}
+/** Build the exact request shape observed in successful current Trae CN logs. */
+declare function buildTraeModelDetailRequest(configName?: string, custom?: boolean): TraeModelDetailRequest;
+//#endregion
+//#region src/protocol.d.ts
+declare const TRAE_CN_AGENT_TASK_PATH = "/api/agent/v3/create_agent_task";
+declare const TRAE_CN_TITLE_PATH = "/api/agent/v3/llm_utils_chat";
+interface OpenAITextMessage {
+  role: 'assistant' | 'system' | 'user';
+  content: string;
+}
+interface TraeAgentTaskBody {
+  messages: {
+    role: OpenAITextMessage['role'];
+    content: {
+      type: 'text';
+      text: string;
+    }[];
+  }[];
+  model: string;
+  function: string;
+  stream: true;
+  request_id: string;
+  session_id: string;
+  max_tokens?: number;
+}
+/**
+ * Evidence-bounded body draft. It is intentionally pure and offline; the
+ * network client remains disabled until a controlled request validates it.
+ */
+declare function buildTraeAgentTaskBody(messages: readonly OpenAITextMessage[], model: string, options?: {
+  maxTokens?: number;
+  requestId?: string;
+  sessionId?: string;
+}): TraeAgentTaskBody;
+type TraeHeaderProfile = 'agent-task' | 'model-detail' | 'raw-chat' | 'native-curl';
+/**
+ * Numeric version code sent when the persisted build version is not a plain
+ * integer. The upstream binds `x-app-version-code` / `x-ide-version-code` as a
+ * number: Trae stores `iCubeLastVersion` as a dotted build string (observed
+ * `2.3.76922` on TRAE SOLO CN 0.1.56), which the server rejects with
+ * `4001 ... expr_path=app_version_code, cause=parameter type does not match
+ * binding data`. Verified 2026-08-29: with a numeric code the same request
+ * returns HTTP 200 + `text/event-stream` on
+ * `/api/agent/v3/llm_utils_chat` (`solo_work_lite`).
+ *
+ * Only the *format* of this field is normalised. Machine, device and app
+ * version stay exactly as persisted — nothing here impersonates a device.
+ */
+declare const TRAE_VERSION_CODE_FALLBACK = "20260716";
+/** Keep a purely numeric build version; fall back when it cannot bind. */
+declare function normalizeTraeVersionCode(buildVersion: string | undefined): string;
+declare function buildTraeCnHeaders(credential: TraeCredential, identity: TraeIdentity, options?: {
+  appId?: string;
+  requestId?: string;
+  profile?: TraeHeaderProfile;
+}): Record<string, string>;
+declare function traeEndpoint(baseUrl: string, path: string): string;
+//#endregion
+//#region src/raw-chat.d.ts
+declare const TRAE_RAW_CHAT_V2_PATH = "/api/ide/v2/llm_raw_chat";
+declare const TRAE_RAW_CHAT_V1_PATH = "/api/ide/v1/llm_raw_chat";
+type RawChatRole = 'assistant' | 'system' | 'tool' | 'user';
+interface RawChatTextContent {
+  type: 'text';
+  text: string;
+}
+interface RawChatImageContent {
+  type: 'image_url';
+  image_url: {
+    url: string;
+  };
+}
+type RawChatContent = RawChatTextContent | RawChatImageContent;
+interface RawChatToolCall {
+  id: string;
+  type: 'function';
+  function: {
+    name: string;
+    arguments: string;
+  };
+}
+interface RawChatMessage {
+  role: RawChatRole;
+  content: string | RawChatContent[];
+  tool_call_id?: string;
+  tool_calls?: RawChatToolCall[];
+}
+interface RawChatTool {
+  type: 'function';
+  function: {
+    name: string;
+    description?: string;
+    parameters: Record<string, unknown>;
+  };
+}
+interface TraeRawChatDraft {
+  model: string;
+  messages: RawChatMessage[];
+  stream: true;
+  tools?: RawChatTool[];
+  max_tokens?: number;
+  temperature?: number;
+  reasoning_effort?: string;
+  extra_info?: Record<string, unknown>;
+}
+/**
+ * Evidence-bounded OpenAI-like draft inferred from Trae's LLMRaw* DTO symbols.
+ * Pure/offline only: the upstream remains disabled until one controlled probe.
+ */
+declare function buildTraeRawChatDraft(input: {
+  model: string;
+  messages: readonly RawChatMessage[];
+  tools?: readonly RawChatTool[];
+  maxTokens?: number;
+  temperature?: number;
+  reasoningEffort?: string;
+  extraInfo?: Record<string, unknown>;
+}): TraeRawChatDraft;
+type RawChatDelta = {
+  type: 'text';
+  text: string;
+} | {
+  type: 'reasoning';
+  text: string;
+} | {
+  type: 'tool-call';
+  index: number;
+  id?: string;
+  name?: string;
+  arguments?: string;
+} | {
+  type: 'usage';
+  inputTokens?: number;
+  outputTokens?: number;
+  totalTokens?: number;
+} | {
+  type: 'done';
+  finishReason: string;
+} | {
+  type: 'unknown';
+  value: unknown;
+};
+/** Decode OpenAI-like raw-chat chunks while preserving unknown structures. */
+declare function decodeRawChatChunk(value: unknown): RawChatDelta[];
+//#endregion
+//#region src/raw-envelope.d.ts
+interface TraeFusionRawChatEnvelope {
+  arg: TraeRawChatDraft;
+  args_hash: string;
+  config_json: string;
+}
+/** Stable JSON hash candidate used by the native DTO's arg/args_hash fields. */
+declare function hashTraeRawChatArg(arg: TraeRawChatDraft): string;
+/**
+ * Evidence-bounded fusion envelope candidate. The native DTO exposes exactly
+ * arg/args_hash/config_json, but the hash algorithm and config_json contents
+ * remain candidates until a live response validates them.
+ */
+declare function buildTraeFusionRawChatEnvelope(arg: TraeRawChatDraft, config: Record<string, unknown>): TraeFusionRawChatEnvelope;
+//#endregion
+//#region src/raw-runtime-config.d.ts
+interface TraeRawChatRuntimeConfig {
+  configName: string;
+  modelName: string;
+  promptMaxTokens?: number;
+  maxTokens?: number;
+  maxTurn?: number;
+  multimodal?: boolean;
+  nativeFunctionCall?: boolean;
+  passBackReasoning?: boolean;
+  useV2Process?: boolean;
+  maxModeEnabled?: boolean;
+  maxToolcallChars?: number;
+  streamThrottleEnabled?: boolean;
+  customConfig?: Record<string, unknown>;
+}
+/** Merge safe current-cache facts with observed behavior flags; no network credentials enter this object. */
+declare function traeRawChatExtraInfo(config: TraeRawChatRuntimeConfig): Record<string, unknown>;
+declare function buildTraeRawChatRuntimeConfig(modelName: string, cached: TraeCachedModelConfig | undefined, behavior?: TraeRawChatBehaviorConfig): TraeRawChatRuntimeConfig;
+//#endregion
+//#region src/raw-resolver.d.ts
+interface TraeRawResolverResult {
+  identity: TraeIdentity;
+  runtime: TraeRawChatRuntimeConfig;
+}
+/** Resolve current desktop identity and safe cached model config for capability probing. */
+declare function resolveTraeRawRuntime(store: TraeCredentialStore, modelName: string): Promise<TraeRawResolverResult>;
+//#endregion
+//#region src/raw-fingerprint.d.ts
+/** Stable non-secret fingerprint for capability-cache invalidation. */
+declare function rawCapabilityFingerprint(input: {
+  endpoint: string;
+  edition: string;
+  identity: Pick<TraeIdentity, 'appVersion' | 'buildVersion'>;
+  runtime: TraeRawChatRuntimeConfig;
+}): string;
+//#endregion
+//#region src/raw-capability.d.ts
+type TraeRawChatCapability = {
+  available: true;
+  contentType: string | null;
+} | {
+  available: false;
+  reason: 'authentication' | 'credit' | 'rate' | 'protocol' | 'transport' | 'server';
+  status: number;
+};
+/** One short non-tool request decides whether Raw Chat may become primary. */
+declare function probeTraeRawChatCapability(client: TraeUpstreamClient, signal?: AbortSignal): Promise<TraeRawChatCapability>;
+//#endregion
+//#region src/raw-diagnostic.d.ts
+type TraeRawDiagnosticState = 'disabled' | 'unchecked' | 'available' | 'protocol-gated' | 'authentication' | 'credit' | 'rate' | 'transport' | 'server';
+interface TraeRawDiagnostic {
+  state: TraeRawDiagnosticState;
+  checkedAtMs?: number;
+  status?: number;
+}
+/** Project capability facts to a redacted, user-safe status. */
+declare function rawCapabilityDiagnostic(enabled: boolean, capability?: TraeRawChatCapability, checkedAtMs?: number): TraeRawDiagnostic;
+//#endregion
+//#region src/raw-gateway.d.ts
+interface TraeRawGatewayOptions {
+  raw: TraeUpstreamClient;
+  solo: TraeUpstreamClient;
+  endpoint: string;
+  edition: string;
+  identity: Pick<TraeIdentity, 'appVersion' | 'buildVersion'>;
+  runtime: TraeRawChatRuntimeConfig;
+  enabled?: boolean;
+}
+interface TraeRawGateway {
+  upstream: TraeUpstreamClient;
+  probe(signal?: AbortSignal): ReturnType<typeof probeTraeRawChatCapability>;
+  diagnostic(): TraeRawDiagnostic;
+  invalidate(): void;
+}
+/** Assemble the opt-in capability state and safe Raw→SOLO routing. */
+declare function createTraeRawGateway(options: TraeRawGatewayOptions): TraeRawGateway;
+//#endregion
+//#region src/raw-upstream.d.ts
+interface TraeRawChatConfig {
+  model: string;
+  configName: string;
+  promptSet?: string;
+  abVersion?: string;
+  passBackReasoning: boolean;
+  extraInfo?: Record<string, unknown>;
+  runtime?: TraeRawChatRuntimeConfig;
+}
+interface TraeRawChatClientOptions {
+  credential: () => Promise<TraeCredential>;
+  identity: () => Promise<TraeIdentity>;
+  config: TraeRawChatConfig;
+  baseUrl?: string;
+  fetchImpl?: typeof fetch;
+}
+type TraeRawChatFailureReason = 'empty' | 'json' | 'schema' | 'permission' | 'model' | 'generic-http' | 'other';
+declare function classifyTraeRawChatFailure(message: string): TraeRawChatFailureReason;
+/**
+ * Evidence-gated Raw Chat client. It is fully testable through injected fetch,
+ * but production callers must not construct it without verified config values.
+ */
+declare class TraeRawChatUpstreamClient {
+  private readonly options;
+  private readonly fetchImpl;
+  constructor(options: TraeRawChatClientOptions);
+  chatStream(bodyJson: string, signal?: AbortSignal): Promise<TraeChatResult>;
+}
+//#endregion
+//#region src/raw-capability-state.d.ts
+interface TraeRawCapabilitySnapshot {
+  capability?: TraeRawChatCapability;
+  checkedAtMs?: number;
+  fingerprint?: string;
+}
+/** In-memory capability state; success/failure expires and config changes invalidate it. */
+declare class TraeRawCapabilityState {
+  private readonly ttlMs;
+  private snapshot;
+  constructor(ttlMs?: number);
+  current(fingerprint: string, now?: number): TraeRawChatCapability | undefined;
+  record(fingerprint: string, capability: TraeRawChatCapability, now?: number): void;
+  inspect(): Readonly<TraeRawCapabilitySnapshot>;
+  invalidate(): void;
+}
+//#endregion
+//#region src/raw-capability-controller.d.ts
+interface TraeRawCapabilityControllerOptions {
+  client: TraeUpstreamClient;
+  state?: TraeRawCapabilityState;
+  enabled?: boolean;
+}
+/** Explicitly-triggered, single-flight Raw Chat capability checks. */
+declare class TraeRawCapabilityController {
+  private readonly options;
+  private readonly state;
+  private enabled;
+  private inflight;
+  constructor(options: TraeRawCapabilityControllerOptions);
+  current(fingerprint: string): TraeRawChatCapability | undefined;
+  setEnabled(enabled: boolean): void;
+  inspect(): Readonly<TraeRawCapabilitySnapshot>;
+  isEnabled(): boolean;
+  invalidate(): void;
+  probe(fingerprint: string, signal?: AbortSignal): Promise<TraeRawChatCapability>;
+}
+//#endregion
+//#region src/fallback-upstream.d.ts
+interface TraeFallbackUpstreamOptions {
+  primary: TraeUpstreamClient;
+  fallback: TraeUpstreamClient;
+  onFallback?: (result: Extract<TraeChatResult, {
+    ok: false;
+  }>) => void;
+}
+/**
+ * Raw Chat first, SOLO Remote second. Fallback is intentionally narrow:
+ * only definitive pre-stream schema/route incompatibilities may retry the same
+ * user request. Authentication, credit, rate, cancellation, transport/server
+ * failures, and every successful Response are never replayed.
+ */
+declare class TraeFallbackUpstreamClient implements TraeUpstreamClient {
+  private readonly options;
+  constructor(options: TraeFallbackUpstreamOptions);
+  chatStream(bodyJson: string, signal?: AbortSignal): Promise<TraeChatResult>;
+  private canFallback;
+}
+//#endregion
+//#region src/gated-upstream.d.ts
+interface TraeGatedUpstreamOptions {
+  raw: TraeUpstreamClient;
+  solo: TraeUpstreamClient;
+  capability(): TraeRawChatCapability | undefined;
+  onFallback?: (failure: Extract<TraeChatResult, {
+    ok: false;
+  }>) => void;
+}
+/** Select Raw Chat only after a successful capability probe; SOLO is the safe default. */
+declare class TraeGatedUpstreamClient implements TraeUpstreamClient {
+  private readonly options;
+  constructor(options: TraeGatedUpstreamOptions);
+  chatStream(bodyJson: string, signal?: AbortSignal): Promise<TraeChatResult>;
+}
+//#endregion
+//#region src/refresh.d.ts
+/** Refresh only editions whose client contract is currently evidenced. */
+declare function refreshTraeCredential(credential: TraeCredential, signal?: AbortSignal): Promise<TraeRefreshOutcome>;
+//#endregion
+//#region src/sse.d.ts
+interface SseEvent {
+  event?: string;
+  data: string;
+  id?: string;
+  retry?: number;
+}
+/** Incremental SSE decoder supporting CRLF, chunk splits and multi-line data. */
+declare class SseDecoder {
+  private buffer;
+  private event;
+  private id;
+  private retry;
+  private data;
+  push(chunk: string): SseEvent[];
+  finish(): SseEvent[];
+  private consumeLine;
+  private dispatch;
+}
+type TraeStreamEvent = {
+  type: 'queue';
+  position?: number;
+} | {
+  type: 'progress';
+  notice: unknown;
+} | {
+  type: 'delta';
+  text: string;
+  reasoning?: string;
+  toolCalls?: unknown;
+} | {
+  type: 'usage';
+  inputTokens?: number;
+  outputTokens?: number;
+  totalTokens?: number;
+  reasoningTokens?: number;
+} | {
+  type: 'done';
+  finishReason: string;
+} | {
+  type: 'unknown';
+  event?: string;
+  data: unknown;
+};
+declare function decodeTraeEvent(event: SseEvent): TraeStreamEvent;
+//#endregion
+//#region src/solo.d.ts
+declare const TRAE_SOLO_FUNCTION = "solo_work_lite";
+declare const TRAE_SOLO_CHAT_PATH = "/api/agent/v3/llm_utils_chat";
+declare const TRAE_SOLO_MODELS_PATH = "/api/ide/v1/get_detail_param";
+declare function prepareSoloBody(source: string, defaultModel?: string): string;
+interface TraeSoloModel {
+  id: string;
+  name: string;
+  contextWindow?: number;
+  maxTokens?: number;
+  reasoning?: TraeReasoningCapability;
+}
+interface TraeSoloClientOptions {
+  credential(): Promise<TraeCredential>;
+  identity(): Promise<TraeIdentity>;
+  baseUrl?: string;
+  fetchImpl?: typeof fetch;
+}
+declare class TraeSoloUpstreamClient {
+  private readonly options;
+  private readonly fetchImpl;
+  constructor(options: TraeSoloClientOptions);
+  fetchModels(signal?: AbortSignal): Promise<TraeSoloModel[]>;
+  chatStream(bodyJson: string, signal?: AbortSignal): Promise<TraeChatResult>;
+}
+//#endregion
+//#region src/solo-bridge.d.ts
+/** Convert Trae's named SSE events into OpenAI chat-completion SSE chunks. */
+declare function bridgeTraeSoloStream(response: Response, model: string): Response;
+/** Native SOLO client wrapper used by the loopback OpenAI adapter. */
+declare class TraeSoloBridge implements TraeUpstreamClient {
+  private readonly upstream;
+  constructor(upstream: TraeUpstreamClient);
+  chatStream(bodyJson: string, signal?: AbortSignal): Promise<TraeChatResult>;
+}
+//#endregion
+//#region src/solo-remote.d.ts
+declare const TRAE_SOLO_REMOTE_BASE = "https://solo.trae.cn/api/remote/v1";
+declare const TRAE_SOLO_REMOTE_MODELS: readonly {
+  name: string;
+  displayName: string;
+  multimodal: boolean;
+}[];
+interface TraeSoloRemoteOptions {
+  credential(): Promise<TraeCredential>;
+  fetchImpl?: typeof fetch;
+  baseUrl?: string;
+  pollIntervalMs?: number;
+  timeoutMs?: number;
+}
+interface TraeRemoteInputMessage {
+  role: string;
+  content: string;
+}
+declare class TraeSoloRemoteClient {
+  private readonly options;
+  private readonly fetchImpl;
+  private readonly baseUrl;
+  private readonly pollIntervalMs;
+  private readonly timeoutMs;
+  constructor(options: TraeSoloRemoteOptions);
+  private headers;
+  chat(messages: readonly TraeRemoteInputMessage[], model: string, signal?: AbortSignal): Promise<{
+    content: string;
+    sessionId: string;
+  }>;
+  fetchModels(signal?: AbortSignal): Promise<TraeDiscoveredModel[]>;
+}
+//#endregion
+//#region src/solo-remote-bridge.d.ts
+/**
+ * Bridges the SOLO remote polling-based API into the shim's stream interface.
+ * The remote API uses create-session + poll-messages rather than raw SSE,
+ * so this bridge converts the final result into a synthetic OpenAI SSE stream.
+ */
+declare class TraeSoloRemoteBridge implements TraeUpstreamClient {
+  private readonly remote;
+  constructor(remote: TraeSoloRemoteClient);
+  chatStream(bodyJson: string, signal?: AbortSignal): Promise<TraeChatResult>;
+}
+//#endregion
+//#region src/delegating-upstream.d.ts
+/** Stable shim dependency whose delegate can be replaced after async setup. */
+declare class TraeDelegatingUpstreamClient implements TraeUpstreamClient {
+  private delegate;
+  constructor(delegate: TraeUpstreamClient);
+  replace(delegate: TraeUpstreamClient): void;
+  chatStream(bodyJson: string, signal?: AbortSignal): Promise<TraeChatResult>;
+}
+//#endregion
+//#region src/usage.d.ts
+/**
+ * Read-only Trae usage/credits client.
+ *
+ * Sources the verified `api.trae.cn` pay/ug endpoints (see
+ * `docs/USAGE_API_RESEARCH.md`). All queries are read-only and do not consume
+ * Trae credits. The per-session consumption detail table is deliberately not
+ * included: the endpoint returns no rows for the current account, so we only
+ * expose what is actually retrievable.
+ */
+declare const TRAE_PAY_BASE = "https://api.trae.cn";
+interface TraeUsageOptions {
+  credential(): Promise<TraeCredential | undefined>;
+  fetchImpl?: typeof fetch;
+  baseUrl?: string;
+  timeoutMs?: number;
+}
+interface TraeUsageSummary {
+  totalAmount: number;
+  consumedAmount: number;
+  consumptionRatio: number;
+}
+interface TraeUsagePack {
+  displayDesc: string;
+  entitlementId: string;
+  endTimeMs: number;
+  currency: number;
+  /** 0 = non-Work/general endpoint, 1 = Work endpoint. */
+  availableEndpoint?: number;
+  creditsLimit?: number;
+  /** Credits consumed from this pack (`usage.credits_amount`). */
+  consumedCredits?: number;
+}
+interface TraeUsageSnapshot {
+  isCreditsBilling: boolean;
+  isDollarUsageBilling: boolean;
+  isPayFreshman: boolean;
+  inTrial: boolean;
+  trialEndTimeMs: number;
+  summary: TraeUsageSummary;
+  packs: TraeUsagePack[];
+}
+interface TraeCheckinStatus {
+  checkedIn: boolean;
+  credits: number;
+  enabled: boolean;
+}
+interface TraeActivityRule {
+  activityId: string;
+  enabled: boolean;
+  activityType: number;
+  startTimeMs: number;
+  endTimeMs: number;
+  workExtra?: Record<string, unknown>;
+}
+interface TraeUsageView {
+  snapshot: TraeUsageSnapshot;
+  checkin: TraeCheckinStatus;
+  activities: TraeActivityRule[];
+}
+/**
+ * A read-only client for the verified Trae usage/credits endpoints.
+ * All methods are safe to call from a plugin and never mutate account state.
+ */
+declare class TraeUsageClient {
+  private readonly options;
+  private readonly fetchImpl;
+  private readonly baseUrl;
+  private readonly timeoutMs;
+  constructor(options: TraeUsageOptions);
+  private authedHeaders;
+  private post;
+  /** Total entitlements / credits and per-pack breakdown. */
+  snapshot(signal?: AbortSignal): Promise<TraeUsageSnapshot>;
+  /** Daily check-in status. */
+  checkinStatus(signal?: AbortSignal): Promise<TraeCheckinStatus>;
+  /** Rewards / activity rules. */
+  activities(signal?: AbortSignal): Promise<TraeActivityRule[]>;
+  /** Convenience: snapshot + check-in + activities in one call (best-effort, non-fatal on missing). */
+  view(signal?: AbortSignal): Promise<TraeUsageView>;
+}
+//#endregion
+//#region src/status-paths.d.ts
+/**
+ * Node-free constants and types shared by the Host and browser halves.
+ * Mirrors the `dsh-workbuddy-connect` status-route pattern so the plugin card
+ * stays consistent with that project's external presentation.
+ */
+/** Plugin-owned usage endpoint consumed by its browser half. */
+declare const TRAE_USAGE_PATH = "/plugins/dsh-connect-trae/usage";
+/** One credit pack and its remaining credit. */
+interface TraeWebCreditAccount {
+  displayDesc: string;
+  remain: number;
+  size: number;
+}
+/** Aggregated usage/credit answer rendered by the plugin card. */
+interface TraeWebCredits {
+  total: number;
+  consumed: number;
+  available: number;
+  workAvailable: number;
+  generalAvailable: number;
+  accounts: readonly TraeWebCreditAccount[];
+}
+/** Editable Trae model row rendered by the plugin-owned settings card. */
+interface TraeWebModel {
+  id: string;
+  name: string;
+  contextWindow?: number;
+  maxTokens?: number;
+  input?: ('text' | 'image')[];
+  creditMultiplier?: number;
+  reasoningSupported?: boolean;
+  reasoning?: {
+    supported: string[];
+    defaultEffort?: string;
+  };
+  baseModelId?: string;
+  maxContext?: boolean;
+  maxContextWindow?: number;
+  maxContextEnabled?: boolean;
+}
+/** Daily check-in status rendered by the card. */
+interface TraeWebCheckin {
+  checkedIn: boolean;
+  credits: number;
+}
+/** One reward activity rule (name + work/general credits when present). */
+interface TraeWebActivity {
+  activityId: string;
+  enabled: boolean;
+  workCredits?: number;
+  generalCredits?: number;
+}
+interface TraeWebAccount {
+  id: string;
+  accountName: string;
+  edition: 'cn' | 'sg' | 'solo' | 'solo-sg';
+  source: 'desktop' | 'dsh';
+  tokenExpiresAtMs: number;
+  selected: boolean;
+}
+/** The JSON document the plugin card renders. */
+type TraeWebUsage = {
+  status: 'signed-out';
+  accounts: readonly TraeWebAccount[];
+  message?: string;
+} | {
+  status: 'signed-in';
+  accountId: string;
+  accountName: string;
+  tokenExpiresAtMs: number;
+  accounts: readonly TraeWebAccount[];
+  models: readonly TraeWebModel[];
+  enabledModelIds: readonly string[];
+  enabled1mModelIds: readonly string[];
+  rawChat?: {
+    state: 'disabled' | 'unchecked' | 'available' | 'protocol-gated' | 'authentication' | 'credit' | 'rate' | 'transport' | 'server';
+    checkedAtMs?: number;
+    status?: number;
+  };
+  credits?: TraeWebCredits;
+  creditsError?: string;
+} | {
+  status: 'error';
+  message: string;
+};
+//#endregion
+//#region src/web-status.d.ts
+/** Constructor dependencies. */
+interface TraeUsageRouteOptions {
+  store: TraeCredentialStore;
+  client: TraeUsageClient;
+  /** The last-refreshed Trae raw directory (no generated @1m variants) for card display. */
+  displayModels(): readonly TraeModelInfo[];
+  /** The user's ordinary-model selection stored as model id (= Trae name). */
+  enabledModelIds(): readonly string[];
+  /** The user's 1M selection stored as base-model id. */
+  enabled1mModelIds(): readonly string[];
+  discoverModels?(signal?: AbortSignal): Promise<readonly TraeModelInfo[]>;
+  rawDiagnostic?(): TraeRawDiagnostic;
+}
+/**
+ * Assemble the card's usage document. Sign-in state is read-only; credit is a
+ * live billing answer whose failure degrades to `creditsError` rather than
+ * failing the whole document.
+ */
+declare function traeWebUsage(deps: TraeUsageRouteOptions): Promise<TraeWebUsage>;
+/** Mount the GET usage route on an optional webServer context. */
+declare function registerTraeUsageRoute(ctx: Context, deps: TraeUsageRouteOptions): void;
+//#endregion
+//#region src/index.d.ts
+declare const name = "llm-trae";
+declare const inject: string[];
+declare const TRAE_SETTINGS_NS: import("@deepseek-ai/dsh-settings").SettingsNamespace;
+interface Config {
+  authFile?: string;
+  edition?: 'auto' | 'cn' | 'sg' | 'solo' | 'solo-sg';
+  /** Stable local account selector; tokens remain outside settings. */
+  accountId?: string;
+  /** The last-refreshed Trae raw directory; what the plugin card displays. */
+  lastCatalog?: TraeModelInfo[];
+  /** The user's ordinary-model selection, as model id (= Trae name). */
+  enabledModelIds?: string[];
+  /** The user's 1M selection, as base-model id. */
+  enabled1mModels?: string[];
+  /** Legacy generated runtime catalog; kept for backwards compatibility. */
+  models?: TraeModelInfo[];
+}
+declare const Config: z<Config>;
+declare function apply(ctx: Context, config: Config): void;
+//#endregion
+export { Config, FALLBACK_TRAE_MODELS, type RawChatDelta, type RawChatMessage, type RawChatTool, SseDecoder, type SseEvent, TRAE_CN_AGENT_TASK_PATH, TRAE_CN_TITLE_PATH, TRAE_MODEL_DETAIL_FUNCTIONS, TRAE_MODEL_DETAIL_PATH, TRAE_PAY_BASE, TRAE_PROVIDER, TRAE_RAW_CHAT_V1_PATH, TRAE_RAW_CHAT_V2_PATH, TRAE_REASONING_EFFORTS, TRAE_SETTINGS_NS, TRAE_SOLO_CHAT_PATH, TRAE_SOLO_FUNCTION, TRAE_SOLO_MODELS_PATH, TRAE_SOLO_REMOTE_BASE, TRAE_SOLO_REMOTE_MODELS, TRAE_STREAM_IDLE_TIMEOUT_MS, TRAE_USAGE_PATH, TRAE_VERSION_CODE_FALLBACK, type TraeActivityRule, type TraeCachedModelConfig, TraeCatalog, type TraeChatResult, type TraeCheckinStatus, type TraeCredential, TraeCredentialStore, TraeDelegatingUpstreamClient, type TraeDiscoveredModel, type TraeDiscoveredReasoning, type TraeEdition, TraeFallbackUpstreamClient, type TraeFallbackUpstreamOptions, type TraeFusionRawChatEnvelope, TraeGatedUpstreamClient, type TraeGatedUpstreamOptions, type TraeIdentity, type TraeModelDetailRequest, type TraeModelInfo, type TraeObservedModelConfig, TraeRawCapabilityController, type TraeRawCapabilityControllerOptions, type TraeRawCapabilitySnapshot, TraeRawCapabilityState, type TraeRawChatBehaviorConfig, type TraeRawChatCapability, type TraeRawChatClientOptions, type TraeRawChatConfig, type TraeRawChatFailureReason, type TraeRawChatRuntimeConfig, TraeRawChatUpstreamClient, type TraeRawDiagnostic, type TraeRawDiagnosticState, type TraeRawGateway, type TraeRawGatewayOptions, type TraeRawResolverResult, type TraeReasoningCapability, type TraeReasoningEffort, type TraeShim, TraeSoloBridge, type TraeSoloClientOptions, TraeSoloRemoteBridge, TraeSoloRemoteClient, type TraeSoloRemoteOptions, TraeSoloUpstreamClient, type TraeStorageCandidate, type TraeStreamEvent, type TraeUpstreamClient, TraeUsageClient, type TraeUsageOptions, type TraeUsagePack, type TraeUsageRouteOptions, type TraeUsageSnapshot, type TraeUsageSummary, type TraeUsageView, type TraeWebActivity, type TraeWebCheckin, type TraeWebCredits, type TraeWebUsage, UnconfiguredTraeUpstreamClient, apply, applyReasoningEffort, bridgeTraeSoloStream, buildTraeAgentTaskBody, buildTraeCnHeaders, buildTraeFusionRawChatEnvelope, buildTraeModelDetailRequest, buildTraeRawChatDraft, buildTraeRawChatRuntimeConfig, classifyTraeRawChatFailure, createTraeAdapter, createTraeRawGateway, createTraeShim, decodeRawChatChunk, decodeTraeEvent, decryptTraeStorageValue, discoveredCatalog, hashTraeRawChatArg, identityHeaders, inject, name, normalizeTraeCredential, normalizeTraeVersionCode, parseObservedModelConfig, parseReasoningCapability, parseTraeAuthValue, parseTraeCachedModel, parseTraeModelExtraConfigLogLine, parseTraeRawChatBehaviorConfig, parseTraeRemoteModel, parseTraeStorageDocument, prepareSoloBody, probeTraeRawChatCapability, rawCapabilityDiagnostic, rawCapabilityFingerprint, readTraeCachedModel, readTraeIdentity, refreshTraeCredential, registerTraeUsageRoute, resolveTraeRawRuntime, traeEndpoint, traeOwnAuthPath, traeRawChatExtraInfo, traeStorageCandidates, traeWebUsage };