@toddzheng024/dscode-bundle 0.7.27 → 0.7.29

package/vendor/deepseek/types/model-info.d.ts

@@ -0,0 +1,16 @@
+import type { LlmModelInfo, LlmResolvedModelInfo } from '@deepseek-ai/dsh-llm';
+import type { DeepSeekCatalogModel, DeepSeekConnectionOptions } from './types.ts';
+/** Advertise one catalog entry.
+ * @param provider - registered provider id.
+ * @param model - advisory catalog entry.
+ * @returns selector metadata.
+ */
+export declare function catalogModelInfo(provider: string, model: DeepSeekCatalogModel): LlmModelInfo;
+/** Resolve model capabilities against one configuration generation.
+ * @param connection - validated connection facts.
+ * @param provider - registered provider id.
+ * @param model - requested wire model id.
+ * @returns effective model metadata for this operation.
+ */
+export declare function modelInfo(connection: DeepSeekConnectionOptions, provider: string, model: string): LlmResolvedModelInfo;
+//# sourceMappingURL=model-info.d.ts.map

package/vendor/deepseek/types/models.d.ts

@@ -0,0 +1,4 @@
+import type { DeepSeekCatalogModel } from './types.ts';
+/** Advisory official model entries; deployments may replace the catalog. */
+export declare const DEFAULT_MODELS: DeepSeekCatalogModel[];
+//# sourceMappingURL=models.d.ts.map

package/vendor/deepseek/types/replay.d.ts

@@ -0,0 +1,27 @@
+/** Minimal native thinking metadata; durable Harness blocks own all response text. */
+import type { Message, ReplayEnvelope } from '@deepseek-ai/dsh-llm';
+/** Index-aligned metadata retained alongside each emitted Harness block. */
+export interface ReplayBlock {
+    type: 'text' | 'reasoning' | 'tool-call';
+    signature?: string;
+}
+/** Reject malformed JSON objects at provider and durable-data reads.
+ * @param value - untrusted decoded JSON.
+ * @param code - owning failure category.
+ * @returns the validated object.
+ */
+export declare function object(value: unknown, code?: string): Record<string, unknown>;
+/** Construct response metadata without duplicating the assistant text.
+ * @param model - requested model identity.
+ * @param blocks - metadata in emitted block order.
+ * @returns the versioned envelope persisted by the existing assembler.
+ */
+export declare function replayState(model: string, blocks: ReplayBlock[]): ReplayEnvelope;
+/** Validate native replay, discarding unusable metadata before serializing durable content.
+ * @param message - durable assistant content and source metadata.
+ * @param model - target model; cross-model signatures are not portable.
+ * @param onDegrade - diagnostic for unusable metadata; receives no message content or signatures.
+ * @returns index-aligned metadata, absent for foreign, cross-model or degraded history.
+ */
+export declare function readReplay(message: Message, model: string, onDegrade?: (reason: string) => void): ReplayBlock[] | undefined;
+//# sourceMappingURL=replay.d.ts.map

package/vendor/deepseek/types/request-extensions.d.ts

@@ -0,0 +1,16 @@
+/** Prepare plugin-contributed request fields and commit their delivery after HTTP acceptance. */
+import type { DeepSeekLlmApiExtensionRequest } from '@deepseek-ai/dsh-deepseek-llm-api-extensions';
+import type { DeepSeekAdapterOptions } from './types.ts';
+/**
+ * Merge contributions without replacing Messages fields. Preparation and
+ * acceptance failures report REQUEST_EXTENSION.
+ * @param body - serialized Messages request before extension fields.
+ * @param options - request identity, purpose, and cancellation.
+ * @param prepare - contributor registry captured for this adapter.
+ * @returns HTTP payload and a commit to invoke only after a successful HTTP response.
+ */
+export declare function prepareRequestExtensions(body: DeepSeekLlmApiExtensionRequest['body'], options: Omit<DeepSeekLlmApiExtensionRequest, 'body'>, prepare: DeepSeekAdapterOptions['prepareExtensions']): Promise<{
+    payload: string;
+    accept(): Promise<void>;
+}>;
+//# sourceMappingURL=request-extensions.d.ts.map

package/vendor/deepseek/types/request-files.d.ts

@@ -0,0 +1,49 @@
+/** Shared Files resolution, bounded stale-id recovery, and normalized-image diagnostics. */
+import type { RequestImageAttachment } from '@deepseek-ai/dsh-attachment';
+import type { DeepSeekFileStore, DeepSeekFileConnection, DeepSeekFilePolicy } from './file-store.ts';
+import type { DeepSeekFileId } from './file-id.ts';
+/** Position of an image occurrence in the request's conversation messages. */
+export interface ImageWireLocation {
+    message: number;
+    image: number;
+}
+/** A file upload failure eligible for request-wide inline fallback. */
+export declare class FileResolutionFailure extends Error {
+    constructor(cause: unknown);
+}
+/** Files state owned by one model request, including at most one stale-id retry. */
+export declare class RequestFiles {
+    private readonly files;
+    private readonly connection;
+    private readonly policy;
+    private readonly timeoutMs;
+    private readonly signal;
+    private readonly activity;
+    private used;
+    private retried;
+    constructor(files: DeepSeekFileStore, connection: DeepSeekFileConnection, policy: DeepSeekFilePolicy, timeoutMs: number, signal: AbortSignal, activity: () => void);
+    /** Reset occurrence tracking before serializing the next HTTP attempt. */
+    beginAttempt(): void;
+    /**
+     * Resolve a retained image under its own upload deadline.
+     * @param version - prepared request image.
+     * @param location - occurrence used by provider-rejection diagnostics.
+     * @returns the reusable provider id.
+     */
+    resolve(version: RequestImageAttachment, location: ImageWireLocation): Promise<DeepSeekFileId>;
+    /**
+     * Invalidate rejected mappings; only the first stale-id response permits another request.
+     * @param detail - provider error fields used for stale-id classification.
+     * @returns whether the caller should serialize and dispatch again.
+     */
+    retry(detail: string): Promise<boolean>;
+    /**
+     * Attribute a normalized-image rejection to the actual uploaded image occurrences.
+     * @param status - rejected request's HTTP status.
+     * @param message - provider's error message.
+     * @param detail - provider error classification fields.
+     * @returns the image diagnostic or the original provider message.
+     */
+    errorMessage(status: number, message: string, detail: string): string;
+}
+//# sourceMappingURL=request-files.d.ts.map

package/vendor/deepseek/types/request-pricing.d.ts

@@ -1,44 +1,56 @@
 /**
- * Provider-side request-image pricing for DeepSeek routes: reproduces the
- * adapter's deterministic request projection (per-model pixel budget,
- * oldest-first offload under the raw-byte and count budgets) and prices every
- * retained image with the published v4 vision-token accounting. Consumed
- * synchronously by the token meter through `LlmAdapter.imageRequestPricing`;
- * provider usage remains the authoritative anchor for completed requests.
+ * Provider-side request-image pricing for DeepSeek routes: prices every
+ * retained surface occurrence at its per-model request target with
+ * the published vision-token accounting, and every occurrence the surface
+ * marks offloaded as its placeholder text. Consumed synchronously by the
+ * token meter through `LlmAdapter.imageRequestPricing`; provider usage
+ * remains the authoritative anchor for completed requests.
  *
  * @module dsh-llm-deepseek/request-pricing
  */
 import type { ImageAttachmentAccessResolver, LlmImageRequestPricing } from '@deepseek-ai/dsh-llm';
-import type { ImageRequestPolicy } from '@deepseek-ai/dsh-attachment';
-import type { DeepSeekCatalogModel, DeepSeekConnectionOptions } from './adapter.ts';
+import type { ImageAttachmentRef, ImageRequestTarget } from '@deepseek-ai/dsh-attachment';
+import type { DeepSeekCatalogModel, DeepSeekConnectionOptions } from './types.ts';
 /** Default bound on accumulated file-referenced image bytes per request. */
 export declare const DEFAULT_MAX_REQUEST_FILES_BYTES: number;
 /** Provider request image-count limit. */
 export declare const DEFAULT_MAX_IMAGES_PER_REQUEST = 600;
-/** Total-pixel budget matching DeepSeek's normal vision projection. */
-export declare const DEFAULT_REQUEST_IMAGE_PIXEL_BUDGET = 640000;
 /** Total-pixel budget matching provider low-detail image input. */
 export declare const DEFAULT_LOW_DETAIL_IMAGE_PIXEL_BUDGET: number;
 /** Encoded-byte target for one deterministic model-request image; the smallest quality-ladder output is used when no quality fits. */
 export declare const DEFAULT_REQUEST_IMAGE_MAX_BYTES: number;
 /**
- * Resolve the request-image budgets owned by one DeepSeek model route.
+ * Provider per-side limit for a request carrying 15 or more images, applied
+ * to every request image so the image count never changes a projection.
+ */
+export declare const REQUEST_IMAGE_MAX_DIMENSION = 4096;
+/**
+ * Resolve the encoded-byte target one DeepSeek model route applies to every request image.
+ * @param model - Advertised model route and its optional image overrides.
+ * @returns the route's encoded-byte target.
+ * @internal
+ */
+export declare function resolveRequestImageMaxBytes(model: DeepSeekCatalogModel): number;
+/**
+ * Resolve the deterministic request target one DeepSeek model route chooses
+ * for one source image: the published token grid unless the model overrides
+ * it with a pixel budget, then the provider per-side limit, then the route's
+ * encoded-byte target. Small images are never enlarged.
  * @param model - Advertised model route and its optional image overrides.
- * @returns Complete pixel and encoded-byte budgets.
+ * @param source - intrinsic dimensions of the normalized attachment.
+ * @returns Complete request dimensions and encoded-byte target.
  * @internal
  */
-export declare function resolveRequestImagePolicy(model: DeepSeekCatalogModel): ImageRequestPolicy;
+export declare function resolveRequestImageTarget(model: DeepSeekCatalogModel, source: Pick<ImageAttachmentRef, 'width' | 'height'>): ImageRequestTarget;
 /**
  * Build the request-image pricing for one DeepSeek route from a validated
  * connection snapshot. Uncatalogued and text-only models price every
  * occurrence as its deterministic text substitution; image-capable models
- * reproduce the adapter's first-stage oldest-first offload from durable byte
- * lengths and price retained images by their projected request dimensions,
- * with each occurrence's handle or placeholder text built through the same
- * access resolution the serializer uses. The base64 fallback's tighter inline
- * budget is not reproduced, so a fallback request can only cost less than
- * this estimate; access paths resolve at pricing time, so a path that changes
- * before the request only shifts the text price by its own length.
+ * price an offloaded occurrence as its placeholder text and a retained one by
+ * its projected request dimensions, with each occurrence's handle or
+ * placeholder text built through the same access resolution the serializer
+ * uses. Access paths resolve at pricing time, so a path that changes before
+ * the request only shifts the text price by its own length.
  * @param connection - validated connection facts of the pricing resolution.
  * @param model - exact model id named by the request header.
  * @param resolveAccess - current execution-world access resolution shared with request serialization.

package/vendor/deepseek/types/serialize.d.ts

@@ -1,85 +1,20 @@
-/**
- * Serialize harness messages into DeepSeek chat completions. Text-only
- * requests retain string user content; the image path resolves durable
- * attachments into ordered file-id or inline parts. Tool-result images follow their
- * string-only tool messages in a separate user message.
- * @module dsh-llm-deepseek/serialize
- */
-import type { ContentBlock, GenerateOptions, ImageAttachmentAccessResolver, Message } from '@deepseek-ai/dsh-llm';
+/** Map system snapshots and conversation turns to Messages using the configured route capability. */
+import type { GenerateOptions, ImageAttachmentAccessResolver, RequestMessage } from '@deepseek-ai/dsh-llm';
 import type { ImageAttachmentRef, RequestImageAttachment } from '@deepseek-ai/dsh-attachment';
-import type { WireMessage, WireRequest } from './types.ts';
-/** Adapter-level request defaults (from plugin config). */
-export interface RequestDefaults {
-    thinking?: 'enabled' | 'disabled' | undefined;
-    reasoningEffort?: 'off' | 'low' | 'high' | 'max' | undefined;
-}
-/** Provider representation for every retained image in one request. */
-export type ImageRequestRepresentation = {
-    kind: 'file';
-    /** Resolve a retained request version to a reusable DeepSeek file id. */
-    resolveFileId: (version: RequestImageAttachment, block: Extract<ContentBlock, {
-        type: 'image';
-    }>, location: ImageWireLocation) => Promise<string>;
-} | {
-    kind: 'base64';
-};
-/** Dependencies required only when the request contains image input. */
-export interface ImageSerializationOptions {
-    /** One representation used for every retained image in this request. */
-    representation: ImageRequestRepresentation;
-    /** Request versions prepared for the conservatively retained normalized attachments, keyed by attachment id. */
-    requestImages: ReadonlyMap<ImageAttachmentRef['attachmentId'], RequestImageAttachment>;
-    /** Resolve current tool access independently from deterministic request-image versions. */
-    resolveImageAccess?: ImageAttachmentAccessResolver;
-    /** Positive bound on accumulated represented image bytes. */
-    maxRequestImageBytes: number;
-    /** Maximum represented images in one request. */
-    maxImagesPerRequest?: number;
-    /** Represented-byte removal step applied after the request exceeds its byte bound. */
-    byteQuantum?: number;
-    /** Image-count removal step applied after the request exceeds its count bound. */
-    countQuantum?: number;
-}
-/** Durable message and image ordinal used in provider diagnostics. */
-export interface ImageWireLocation {
-    message: number;
-    image: number;
-}
-/**
- * Serialize the conversation. `tool-result` blocks become standalone
- * `{role: 'tool'}` messages; the harness puts each tool result in its own
- * user-role message, so a mixed user message contributes its text first and
- * its tool results as separate wire messages after.
- * @param messages - the harness conversation, in order.
- * @returns the wire messages; order preserved, each tool result expanded into its own entry.
- */
-export declare function serializeMessages(messages: Message[]): WireMessage[];
-/**
- * Serialize image-capable history after resolving durable attachments.
- * Consecutive tool results keep string `tool` messages and share one following
- * user message containing their images.
- * @param messages - transient request history after request-size offloading.
- * @param images - prepared request versions, one provider representation, and its budget.
- * @returns ordered DeepSeek wire messages.
- */
-export declare function serializeMessagesWithImages(messages: readonly Message[], images: ImageSerializationOptions): Promise<WireMessage[]>;
-/**
- * Build the full wire request. Always streaming (`stream: true`, usage
- * reporting on); optional fields are omitted rather than sent as null, so
- * provider defaults apply.
- * @param options - the harness request (model, history, system, tools, sampling).
- * @param defaults - adapter-level thinking defaults; undefined fields put nothing on the wire.
- * @returns the chat-completions request body.
- */
-export declare function serializeRequest(options: GenerateOptions, defaults?: RequestDefaults): WireRequest;
-/**
- * Build one image-capable request while keeping durable bytes out of session
- * messages. Oversized oldest images become per-image text after their
- * exact request-version byte lengths are known and before provider serialization.
- * @param options - harness request containing image-capable user content.
- * @param images - request versions, optional current access resolver, and request bounds.
- * @param defaults - adapter-level thinking defaults.
- * @returns the fully materialized DeepSeek request body.
+import type { DeepSeekConnectionOptions as Connection } from './types.ts';
+import type { DeepSeekFileId } from './file-id.ts';
+import type { WireRequest } from './wire-types.ts';
+/** Serialize one complete request using already prepared image bytes.
+ * User and tool-result content omits reasoning and tool-call blocks.
+ * Empty user messages are skipped; empty tool results retain their call ids.
+ * @param options - provider-neutral request.
+ * @param connection - validated defaults and thinking policy.
+ * @param history - image-projected history with complete system snapshots; durable messages remain unchanged.
+ * @param images - request versions for retained images.
+ * @param access - execution-world paths for image descriptions.
+ * @param onReplayDegrade - diagnostic for discarded native replay metadata.
+ * @param fileIds - resolved Files references; omission selects inline image bytes.
+ * @returns the Messages API JSON body.
  */
-export declare function serializeRequestWithImages(options: GenerateOptions, images: ImageSerializationOptions, defaults?: RequestDefaults): Promise<WireRequest>;
+export declare function serialize(options: GenerateOptions, connection: Connection, history: readonly RequestMessage[], images: ReadonlyMap<ImageAttachmentRef['attachmentId'], RequestImageAttachment>, access: ImageAttachmentAccessResolver, onReplayDegrade?: (reason: string) => void, fileIds?: ReadonlyMap<ImageAttachmentRef['attachmentId'], DeepSeekFileId>): WireRequest;
 //# sourceMappingURL=serialize.d.ts.map

package/vendor/deepseek/types/sse.d.ts

@@ -1,24 +1,8 @@
-/**
- * Decode an SSE byte stream into event `data` payloads. Framing — chunk
- * reassembly, UTF-8/CRLF/BOM handling, comment and non-data field skipping,
- * multi-`data:` joining — is `eventsource-parser`'s. Comments are reported
- * only through an optional transport-activity callback. This module keeps the
- * DeepSeek protocol: the literal `[DONE]` is yielded so the caller owns final
- * flushing, and EOF before it raises {@link LlmError}. Framing is spec-strict:
- * an event dispatches only on its blank-line terminator, so an unterminated
- * tail at EOF is truncation, not a flushable payload.
- *
- * @module dsh-llm-deepseek/sse
+/** SSE framing delegated to eventsource-parser; JSON errors remain provider failures. */
+/** Decode complete SSE frames without treating an unterminated tail as an event.
+ * @param body - provider response bytes.
+ * @param activity - pulse the idle watchdog for events and heartbeat comments.
+ * @returns JSON events, including message_stop; the translator owns completion.
  */
-/** The terminal payload DeepSeek (and OpenAI) send after the last chunk. */
-export declare const DONE = "[DONE]";
-/**
- * Parse an SSE byte stream into data payloads. Yields `[DONE]` as the final
- * value and returns; throws `LlmError('STREAM_CLOSED')` when the stream ends
- * without it (truncated response — the model call cannot be trusted).
- * @param stream - raw SSE bytes; reads may split anywhere, including mid-UTF-8 sequence.
- * @param onComment - optional transport-activity callback; comments never enter the yielded payload stream.
- * @returns each event's data payload in arrival order, the `[DONE]` sentinel last.
- */
-export declare function parseSse(stream: ReadableStream<BufferSource>, onComment?: (comment: string) => void): AsyncGenerator<string>;
+export declare function parseSse(body: ReadableStream<BufferSource>, activity: () => void): AsyncGenerator<Record<string, unknown>>;
 //# sourceMappingURL=sse.d.ts.map

package/vendor/deepseek/types/translate.d.ts

@@ -1,37 +1,14 @@
-/**
- * Translate DeepSeek SSE payloads with one stateful harness block per content, reasoning, or tool
- * call index. An empty initial reasoning delta does not open a block. Finish reason and the latest
- * usage are deferred until `[DONE]`, covering both finish-attached and trailing usage-only shapes
- * while ensuring no chunk follows `finish`.
- *
- * Translate DeepSeek wire chunks into the harness `StreamChunk` protocol.
- * @module dsh-llm-deepseek/translate
- */
-import type { FinishReason, StreamChunk, TokenUsage } from '@deepseek-ai/dsh-llm';
-import type { WireUsage } from './types.ts';
-/**
- * Map the wire finish_reason vocabulary to the harness FinishReason.
- * @param reason - the wire `finish_reason` string.
- * @returns the mapped reason; unrecognized values (content_filter, …) become `{kind: 'error'}` with the uppercased value as `code`.
- */
-export declare function mapFinishReason(reason: string): FinishReason;
-/**
- * Map wire usage fields. DeepSeek's `prompt_tokens` INCLUDES cache hits
- * (`prompt_tokens = prompt_cache_hit_tokens + prompt_cache_miss_tokens`,
- * api/create-chat-completion); the harness TokenUsage convention is
- * DISJOINT counts, so cache reads are subtracted out of `inputTokens`.
- * @param usage - wire usage from the finish chunk or the trailing usage-only chunk.
- * @returns disjoint harness counts; an exact total is present only when the
- *   aggregate prompt/completion counters are valid and agree with any wire total.
- */
-export declare function mapUsage(usage: WireUsage): TokenUsage;
-/**
- * Consume SSE data payloads (ending with `[DONE]`) and yield StreamChunks.
- * Malformed JSON payloads abort the stream with `MALFORMED_RESPONSE`.
- * @param payloads - SSE data payloads from {@link parseSse}, `[DONE]`-terminated.
- * @returns deltas as they arrive; `block-end`s, `usage`, and `finish` are all deferred to the `[DONE]` sentinel.
- *   A `stop` (or absent) finish with no opened blocks is a degenerate provider completion and maps to an
- *   `EMPTY_RESPONSE` error finish instead of a successful empty message.
- */
-export declare function translate(payloads: AsyncIterable<string>): AsyncGenerator<StreamChunk>;
+/** Translate Messages events while preserving block order and cumulative usage. */
+import type { StreamChunk } from '@deepseek-ai/dsh-llm';
+/** Decode a required string from provider JSON.
+ * @param value - provider field.
+ * @returns the validated string.
+ */
+export declare function string(value: unknown): string;
+/** Translate decoded SSE data into the Harness stream protocol.
+ * @param events - framed, decoded provider events in arrival order.
+ * @param model - requested model id stored in durable replay state.
+ * @returns blocks, one final usage value, and exactly one terminal finish.
+ */
+export declare function translate(events: AsyncIterable<Record<string, unknown>>, model: string): AsyncGenerator<StreamChunk>;
 //# sourceMappingURL=translate.d.ts.map

package/vendor/deepseek/types/transport.d.ts

@@ -0,0 +1,15 @@
+/** Normalize HTTP and in-band Messages errors into provider-neutral failures. */
+import { LlmError } from '@deepseek-ai/dsh-llm';
+/** Read only provider error fields used by bounded Files recovery.
+ * @param raw - decoded HTTP error response.
+ * @returns code, type, and message text, without unrelated response fields.
+ */
+export declare function providerErrorDetail(raw: unknown): string;
+/** Classify a provider error without trusting arbitrary response fields.
+ * @param raw - decoded response or in-band error event.
+ * @param status - HTTP status when the error preceded streaming.
+ * @param headers - response headers for retry delay and request identity.
+ * @returns a stable error consumed by LlmRuntime and llm-retry.
+ */
+export declare function providerError(raw: unknown, status: number | undefined, headers?: Headers): LlmError;
+//# sourceMappingURL=transport.d.ts.map