dsh-provider-qoder 0.1.0

package/lib/index.d.ts

@@ -0,0 +1,398 @@
+import z from "@deepseek-ai/schemastery";
+import { GenerateOptions, LlmAdapter, LlmError, LlmErrorOptions, LlmModelInfo, LlmProviderInfo, LlmResolvedModelInfo, Message, StreamChunk, ToolSchema } from "@deepseek-ai/dsh-llm";
+import { CredentialProvider } from "@deepseek-ai/dsh-credentials";
+import { Context } from "@deepseek-ai/cordis";
+
+//#region src/cosy.d.ts
+/**
+ * COSY authentication headers and signature algorithm for Qoder services.
+ *
+ * Implements RSA + AES + MD5 signature generation required by the upstream
+ * Qoder gateway.
+ *
+ * @module dsh-provider-qoder/cosy
+ */
+interface CosyCredentials {
+  userID: string;
+  authToken: string;
+  name: string;
+  email: string;
+  machineID?: string;
+}
+declare function computeSigPath(urlStr: string): string;
+declare function buildAuthHeaders(body: Buffer | string | null, requestURL: string, creds: CosyCredentials): Record<string, string>;
+//#endregion
+//#region src/endpoints.d.ts
+/** Qoder transport endpoints for Global and China service regions. */
+type QoderRegion = 'global' | 'china';
+interface QoderRegionEndpoints {
+  baseUrl: string;
+  openApiUrl: string;
+}
+declare const qoderRegionEndpoints: Record<QoderRegion, QoderRegionEndpoints>;
+declare const qoderGlobalBaseUrl: string;
+declare const qoderGlobalOpenApiUrl: string;
+declare function resolveQoderEndpoints(region?: QoderRegion): QoderRegionEndpoints;
+declare function getQoderChatUrl(region?: QoderRegion): string;
+declare function getQoderModelListUrl(region?: QoderRegion): string;
+declare function getQoderExchangeUrl(region?: QoderRegion): string;
+declare function getQoderUserInfoUrl(region?: QoderRegion): string;
+declare function getQoderUsageUrl(region?: QoderRegion): string;
+//#endregion
+//#region src/logging.d.ts
+/** Bounded, redacted diagnostics shared by Qoder host services. */
+interface QoderLogger {
+  debug?(message: string, ...details: unknown[]): void;
+  warn?(message: string, ...details: unknown[]): void;
+  error?(message: string, ...details: unknown[]): void;
+}
+/** Redact credentials and bound arbitrary provider values before logging them. */
+declare function redactLogValue(value: unknown, depth?: number): unknown;
+/** Parse JSON-shaped diagnostics when possible, then apply the same redaction boundary. */
+declare function redactLogPayload(text: string): unknown;
+//#endregion
+//#region src/auth.d.ts
+interface QoderAuthServiceOptions {
+  fetch?: typeof fetch;
+  timeoutMs?: number;
+  resolveMachineId?: () => string;
+  resolveRegion?: () => QoderRegion;
+  region?: QoderRegion;
+  logger?: QoderLogger;
+}
+declare class QoderAuthService {
+  private readonly cache;
+  private readonly inFlight;
+  private readonly fetchImpl;
+  private readonly timeoutMs;
+  private readonly resolveMachineId;
+  private readonly resolveRegion?;
+  private region?;
+  private readonly logger?;
+  constructor(options?: QoderAuthServiceOptions);
+  setRegion(region: QoderRegion): void;
+  currentRegion(): QoderRegion;
+  clear(pat?: string): void;
+  getCredentials(pat: string, signal?: AbortSignal, region?: QoderRegion): Promise<CosyCredentials>;
+  private exchangeAndResolve;
+  private fetchUserInfo;
+}
+//#endregion
+//#region src/adapter.d.ts
+interface QoderCatalogModel {
+  id: string;
+  name: string;
+  description?: string;
+  contextWindow?: number;
+  maxTokens?: number;
+  source?: string;
+  isReasoning?: boolean;
+  supportsEffort?: boolean;
+  reasoningEfforts?: Array<{
+    id: string;
+    name: string;
+    description?: string;
+  }>;
+  defaultReasoningEffort?: string;
+  priceFactor?: number;
+  contextOptions?: Record<string, {
+    tokenCount?: number;
+    isDefault?: boolean;
+  }>;
+}
+declare const defaultMaxTokens = 32768;
+declare const defaultStreamIdleTimeoutMs: number;
+declare const defaultModels: QoderCatalogModel[];
+interface QoderAdapterOptions {
+  resolvePat: () => Promise<string>;
+  models?: readonly QoderCatalogModel[];
+  providerId?: string;
+  providerName?: string;
+  authService?: QoderAuthService;
+  fetch?: typeof fetch;
+  logger?: QoderLogger;
+  streamIdleTimeoutMs?: number;
+  region?: QoderRegion;
+}
+declare class QoderAdapter extends LlmAdapter {
+  private readonly resolvePat;
+  private catalogModels;
+  private readonly authService;
+  private readonly fetchImpl;
+  private readonly logger?;
+  private streamIdleTimeoutMs;
+  private readonly providerId;
+  private readonly providerName;
+  private region;
+  constructor(options: QoderAdapterOptions);
+  providerInfo(provider: string): LlmProviderInfo;
+  listModels(provider: string): Promise<readonly LlmModelInfo[]>;
+  replaceConfig(models: readonly QoderCatalogModel[], streamIdleTimeoutMs: number, region?: QoderRegion): void;
+  resolveModel(provider: string, modelId: string, signal?: AbortSignal): Promise<LlmResolvedModelInfo>;
+  stream(options: GenerateOptions): AsyncIterable<StreamChunk>;
+  private generate;
+}
+//#endregion
+//#region src/credential-contract.d.ts
+/** Shared Host/browser contract for the one managed Qoder credential. */
+declare const qoderCredentialRef = "QODER_MANAGED_CREDENTIAL";
+/** DSH's local provider uses `env` and `*-env` for ambient credential layers. */
+declare function isEnvironmentCredentialSource(source: string | undefined): boolean;
+//#endregion
+//#region src/credential.d.ts
+declare const managedQoderCredentialRef: import("@deepseek-ai/dsh-credentials").CredentialRef;
+/** Resolve only provider-managed storage; ambient environment layers are intentionally unsupported. */
+declare function resolveManagedQoderPat(credentials: CredentialProvider): Promise<string>;
+//#endregion
+//#region src/encoding.d.ts
+/**
+ * Qoder WAF Body encoding algorithm.
+ *
+ * Re-arranges standard Base64 chunks and translates characters against
+ * a custom alphabet to satisfy Qoder upstream WAF requirements.
+ *
+ * @module dsh-provider-qoder/encoding
+ */
+declare function qoderEncodeBody(plaintext: string | Buffer): string;
+//#endregion
+//#region src/errors.d.ts
+declare class QoderLlmError extends LlmError {
+  constructor(message: string, code?: string, options?: LlmErrorOptions);
+}
+declare function qoderHttpError(message: string, response: {
+  status: number;
+  headers?: Pick<Headers, 'get'>;
+}): QoderLlmError;
+declare function retryAfterMs(value: string | null, nowMs?: number): number | undefined;
+//#endregion
+//#region src/machine-id.d.ts
+/** Read Qoder's machine id or create the DSH-owned fallback. */
+declare function getMachineId(paths?: readonly string[]): string;
+//#endregion
+//#region src/models.d.ts
+declare function normalizeQoderModels(payload: unknown): QoderCatalogModel[];
+/**
+ * Restore Qoder-only metadata after DSH's provider-neutral discovery contract
+ * has retained only id, name, and token limits.
+ */
+declare function mergeQoderDiscoveryMetadata(configured: readonly QoderCatalogModel[], discovered: readonly QoderCatalogModel[]): QoderCatalogModel[];
+declare function hasSameQoderDiscoveryMetadata(left: readonly QoderCatalogModel[] | undefined, right: readonly QoderCatalogModel[]): boolean;
+interface FetchQoderModelsOptions {
+  fetch?: typeof fetch;
+  signal?: AbortSignal;
+  region?: QoderRegion;
+  logger?: QoderLogger;
+}
+declare function fetchQoderModels(credentials: CosyCredentials, options?: FetchQoderModelsOptions): Promise<QoderCatalogModel[]>;
+//#endregion
+//#region src/types.d.ts
+/**
+ * Qoder protocol wire types and definitions.
+ *
+ * @module dsh-provider-qoder/types
+ */
+interface QoderWireToolCall {
+  id: string;
+  type: 'function';
+  function: {
+    name: string;
+    arguments: string;
+  };
+}
+interface QoderWireTool {
+  type: 'function';
+  function: {
+    name: string;
+    description: string;
+    parameters: Record<string, unknown>;
+  };
+}
+interface QoderWireMessage {
+  role: 'system' | 'user' | 'assistant' | 'tool';
+  content: string | null;
+  tool_calls?: QoderWireToolCall[];
+  tool_call_id?: string;
+}
+interface QoderModelConfig {
+  key: string;
+  is_reasoning: boolean;
+  max_output_tokens: number;
+  source: string;
+  context_config?: Record<string, {
+    token_count?: number;
+    is_default?: boolean;
+  }>;
+}
+interface QoderChatContext {
+  chatPrompt: string;
+  imageUrls: null | string[];
+  extra: {
+    context: unknown[];
+    modelConfig: {
+      key: string;
+      is_reasoning: boolean;
+    };
+    originalContent: string;
+  };
+  features: unknown[];
+  text: string;
+}
+interface QoderBusiness {
+  product: string;
+  version: string;
+  type: string;
+  stage: string;
+  id: string;
+  name: string;
+  begin_at: number;
+}
+interface QoderWireRequest {
+  request_id: string;
+  request_set_id: string;
+  chat_record_id: string;
+  session_id: string;
+  stream: true;
+  chat_task: string;
+  is_reply: boolean;
+  is_retry: boolean;
+  source: number;
+  version: string;
+  session_type: string;
+  agent_id: string;
+  task_id: string;
+  code_language: string;
+  chat_prompt: string;
+  image_urls: null;
+  aliyun_user_type: string;
+  system: string;
+  messages: QoderWireMessage[];
+  tools: QoderWireTool[];
+  parameters: {
+    max_tokens: number;
+    reasoning_effort?: string;
+  };
+  chat_context: QoderChatContext;
+  model_config: QoderModelConfig;
+  business: QoderBusiness;
+}
+interface QoderSseEnvelope {
+  statusCodeValue?: number;
+  body?: string;
+}
+interface QoderInnerChunk {
+  id?: string;
+  model?: string;
+  choices?: Array<{
+    index?: number;
+    delta?: {
+      content?: string;
+      role?: string;
+      reasoning_content?: string;
+      tool_calls?: Array<{
+        index?: number;
+        id?: string;
+        type?: string;
+        function?: {
+          name?: string;
+          arguments?: string;
+        };
+      }>;
+    };
+    finish_reason?: string | null;
+  }>;
+  usage?: {
+    prompt_tokens?: number;
+    completion_tokens?: number;
+    total_tokens?: number;
+    prompt_tokens_details?: {
+      cached_tokens?: number;
+      cache_write_tokens?: number;
+    };
+    completion_tokens_details?: {
+      reasoning_tokens?: number;
+    };
+  };
+}
+//#endregion
+//#region src/serialize.d.ts
+declare function validateQoderRequest(options: GenerateOptions, model?: QoderCatalogModel): QoderWireMessage[];
+declare function buildQoderRequestBody(options: GenerateOptions, userId: string, translatedMessages?: QoderWireMessage[], model?: QoderCatalogModel): QoderWireRequest;
+//#endregion
+//#region src/sse.d.ts
+interface QoderSseOptions {
+  onActivity?: () => void;
+}
+declare function parseQoderSse(stream: ReadableStream<Uint8Array>, options?: QoderSseOptions): AsyncGenerator<StreamChunk>;
+//#endregion
+//#region src/translate.d.ts
+declare function translateTools(tools: readonly ToolSchema[] | undefined): QoderWireTool[];
+declare function validateAndTranslateMessages(messages: readonly Message[], systemPrompt?: string): QoderWireMessage[];
+//#endregion
+//#region src/usage.d.ts
+interface QoderSubscriberProfile {
+  id: string;
+  name: string;
+  email: string;
+}
+interface QoderQuota {
+  total: number;
+  used: number;
+  remaining: number;
+  percentage: number;
+  unit: string;
+}
+interface QoderQuotaUsage {
+  userQuota?: QoderQuota;
+  orgResourcePackage?: QoderQuota;
+  totalUsagePercentage?: number;
+  isQuotaExceeded?: boolean;
+  expiresAt?: string;
+  raw?: unknown;
+}
+interface QoderAccountInfo {
+  profile: QoderSubscriberProfile;
+  usage?: QoderQuotaUsage;
+  updatedAt: string;
+}
+interface QoderUsageReaderOptions {
+  authService: QoderAuthService;
+  fetch?: typeof fetch;
+  ttlMs?: number;
+  timeoutMs?: number;
+  resolveRegion?: () => QoderRegion;
+  region?: QoderRegion;
+  logger?: QoderLogger;
+}
+declare class QoderUsageReader {
+  private readonly authService;
+  private readonly fetchImpl;
+  private readonly ttlMs;
+  private readonly timeoutMs;
+  private readonly resolveRegion?;
+  private region?;
+  private readonly logger?;
+  private readonly cache;
+  constructor(options: QoderUsageReaderOptions);
+  setRegion(region: QoderRegion): void;
+  currentRegion(): QoderRegion;
+  readAccount(pat: string, options?: {
+    force?: boolean;
+    signal?: AbortSignal;
+    region?: QoderRegion;
+  }): Promise<QoderAccountInfo>;
+  clear(pat?: string): void;
+  private fetchUsage;
+}
+//#endregion
+//#region src/index.d.ts
+declare const name = "provider-qoder";
+declare const inject: string[];
+interface Config {
+  region?: QoderRegion;
+  models?: QoderCatalogModel[];
+  streamIdleTimeoutMs?: number;
+}
+declare const Config: z<Config>;
+declare function apply(ctx: Context, config?: Config): void;
+//#endregion
+export { Config, CosyCredentials, FetchQoderModelsOptions, QoderAccountInfo, QoderAdapter, QoderAdapterOptions, QoderAuthService, QoderAuthServiceOptions, QoderBusiness, QoderCatalogModel, QoderChatContext, QoderInnerChunk, QoderLlmError, QoderLogger, QoderModelConfig, QoderQuota, QoderQuotaUsage, QoderRegion, QoderRegionEndpoints, QoderSseEnvelope, QoderSseOptions, QoderSubscriberProfile, QoderUsageReader, QoderUsageReaderOptions, QoderWireMessage, QoderWireRequest, QoderWireTool, QoderWireToolCall, apply, buildAuthHeaders, buildQoderRequestBody, computeSigPath, defaultMaxTokens, defaultModels, defaultStreamIdleTimeoutMs, fetchQoderModels, getMachineId, getQoderChatUrl, getQoderExchangeUrl, getQoderModelListUrl, getQoderUsageUrl, getQoderUserInfoUrl, hasSameQoderDiscoveryMetadata, inject, isEnvironmentCredentialSource, managedQoderCredentialRef, mergeQoderDiscoveryMetadata, name, normalizeQoderModels, parseQoderSse, qoderCredentialRef, qoderEncodeBody, qoderGlobalBaseUrl, qoderGlobalOpenApiUrl, qoderHttpError, qoderRegionEndpoints, redactLogPayload, redactLogValue, resolveManagedQoderPat, resolveQoderEndpoints, retryAfterMs, translateTools, validateAndTranslateMessages, validateQoderRequest };