@toddzheng024/dscode-bundle 0.1.0

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

@@ -0,0 +1,163 @@
+/**
+ * `DeepSeekAdapter`: fetch + SSE against a DeepSeek (OpenAI-compatible)
+ * chat-completions endpoint, emitting harness StreamChunks. The adapter is
+ * transport-only: connection facts arrive through a thunk resolved once per
+ * operation and the bearer token through a per-request resolver, so the
+ * registering plugin owns validation, layering, and credential policy.
+ *
+ * @module dsh-llm-deepseek/adapter
+ */
+import { LlmAdapter } from '@deepseek-ai/dsh-llm';
+import type { GenerateOptions, ImageAttachmentAccess, LlmModelInfo, LlmProviderInfo, PreparedAdapterCall, LlmResolvedModelInfo, ModelModality, ResolvedRetryPolicy, StreamChunk, SystemPromptUpdate } from '@deepseek-ai/dsh-llm';
+import type { AttachmentStore, ImageAttachmentRef } from '@deepseek-ai/dsh-attachment';
+import type { CredentialRef } from '@deepseek-ai/dsh-credentials';
+import type { AnonymousUserId } from '@deepseek-ai/dsh-anonymous-user-id';
+import type { DeepSeekLlmApiExtensionRequest, PreparedDeepSeekLlmApiExtensions } from '@deepseek-ai/dsh-deepseek-llm-api-extensions';
+import type { RequestDefaults } from './serialize.ts';
+import { DeepSeekFileStore } from './file-store.ts';
+import type { DeepSeekFilePolicy } from './file-store.ts';
+import type { WireError } from './types.ts';
+/** One optional model entry advertised by the direct-fetch adapter. */
+export interface DeepSeekCatalogModel {
+    /** Wire model id accepted by the configured endpoint. */
+    id: string;
+    /** Selector label; defaults to {@link id}. */
+    name?: string;
+    /** Optional selector detail for deployments with similar model variants. */
+    description?: string;
+    /** Known combined request/response context capacity; omitted when deployment metadata is unavailable. */
+    contextWindow?: number;
+    /** Per-request output cap for this model; omission falls back to the profile's {@link DeepSeekConnectionOptions.maxTokens}. */
+    maxTokens?: number;
+    /** Accepted request modalities; omission is text-only. */
+    inputModalities?: ModelModality[];
+    /** Total-pixel budget for one deterministic request preview, or the 512-by-512 `low` preset. */
+    imagePixelBudget?: number | 'low';
+    /** Encoded-byte target for one deterministic request preview; the smallest quality-ladder output is used when no quality fits. */
+    imageMaxBytes?: number;
+    /**
+     * `'in-history'` declares that the endpoint reads the latest `system`
+     * message at any position of the conversation as the complete effective
+     * system prompt; omission means only a leading system message is read.
+     */
+    systemPromptUpdate?: SystemPromptUpdate;
+}
+/**
+ * Validated connection facts for one operation. The plugin's
+ * `resolveAdapterOptions` is the one explicit resolve step producing this
+ * shape; the adapter trusts it and re-reads it per operation, which is what
+ * makes a configuration change reach the next request without re-registration.
+ */
+export interface DeepSeekConnectionOptions {
+    /** Endpoint base; `/chat/completions` is appended. */
+    baseURL: string;
+    /**
+     * Credential reference of this same resolution, resolved per request.
+     * Travelling with the endpoint is the point: a request can never pair one
+     * generation's URL with another generation's secret. Configuration carries
+     * only this name — a literal key is not a configuration value.
+     */
+    apiKeyEnv: CredentialRef;
+    /** Request defaults applied to every call (thinking mode, effort). */
+    defaults: RequestDefaults;
+    /** Default per-request output cap; explicit request values win. */
+    maxTokens: number;
+    /** Positive context capacity used when the selected model has no exact value. */
+    defaultContextWindow: number;
+    /** Advisory models exposed to discovery consumers; requests remain unrestricted. */
+    models: readonly DeepSeekCatalogModel[];
+    /** Maximum provider idle time while one stream read is outstanding. */
+    streamIdleTimeoutMs: number;
+    /** Maximum accumulated file-referenced image bytes in one request. */
+    maxRequestFilesBytes: number;
+    /** Maximum accumulated base64 image payload after Files API fallback. */
+    maxInlineRequestImageBytes: number;
+    /** Maximum number of represented images in one request. */
+    maxImagesPerRequest: number;
+    /** Raw-byte removal step after the file-reference bound is exceeded. */
+    imageOffloadByteQuantum: number;
+    /** Base64-byte removal step after the inline fallback bound is exceeded. */
+    inlineImageOffloadByteQuantum: number;
+    /** Image-count removal step after the count bound is exceeded. */
+    imageOffloadCountQuantum: number;
+    /** Maximum duration of one request-image Files API resolution. */
+    filesApiTimeoutMs: number;
+    /** Upload expiry, refresh, and quota-recovery policy. */
+    filePolicy: DeepSeekFilePolicy;
+    /** Provider-owned model-request retry policy, already resolved. */
+    retryPolicy: ResolvedRetryPolicy;
+}
+/** Constructor options for {@link DeepSeekAdapter}: the operation-local resolution hooks the plugin owns. */
+export interface DeepSeekAdapterOptions {
+    /** Current validated connection facts; called once per operation. */
+    options: () => DeepSeekConnectionOptions;
+    /**
+     * Resolve the bearer token for the connection facts of one request. The
+     * snapshot is passed in — never re-read — so the key can only ever come
+     * from the same resolution as the endpoint it is sent to. Throws `LlmError`
+     * `MISSING_CREDENTIAL` when no key is available anywhere.
+     */
+    resolveApiKey: (connection: DeepSeekConnectionOptions) => Promise<string>;
+    /** Resolve the harness-home anonymous id shared with telemetry and feedback. */
+    resolveUserId: () => AnonymousUserId;
+    /** Resolve the current durable attachment service; absence rejects image input. */
+    resolveAttachments?: () => AttachmentStore | undefined;
+    /** Bridge one attachment reference into the current model-tool execution world. */
+    resolveImageAccess?: (attachments: AttachmentStore, ref: ImageAttachmentRef) => ImageAttachmentAccess | undefined;
+    /** Resolve the process-wide upload reuse store. */
+    resolveFiles?: () => DeepSeekFileStore;
+    /** Prepare the official API's plugin-contributed top-level fields for one exact wire request. */
+    prepareExtensions: (request: DeepSeekLlmApiExtensionRequest) => Promise<PreparedDeepSeekLlmApiExtensions>;
+}
+/** Default maximum idle interval while an adapter stream read is outstanding. */
+export declare const DEFAULT_STREAM_IDLE_TIMEOUT_MS = 300000;
+/** Default combined request/response context capacity. */
+export declare const DEFAULT_CONTEXT_WINDOW = 1000000;
+/** Default per-request output-token cap. */
+export declare const DEFAULT_MAX_TOKENS = 256000;
+/** Default bound on accumulated base64 image payload after Files API fallback. */
+export declare const DEFAULT_MAX_INLINE_REQUEST_IMAGE_BYTES: number;
+/** Deterministic raw-byte removal step. */
+export declare const DEFAULT_IMAGE_OFFLOAD_BYTE_QUANTUM: number;
+/** Deterministic base64-byte removal step after Files API fallback. */
+export declare const DEFAULT_INLINE_IMAGE_OFFLOAD_BYTE_QUANTUM: number;
+/** Deterministic image-count removal step. */
+export declare const DEFAULT_IMAGE_OFFLOAD_COUNT_QUANTUM = 20;
+/** Default explicit lifetime for uploaded images. */
+export declare const DEFAULT_FILE_EXPIRY_SECONDS: number;
+/** Default proactive refresh window for indexed file ids. */
+export declare const DEFAULT_FILE_REFRESH_MARGIN_SECONDS: number;
+/** Default number of oldest harness-owned files removed on quota recovery. */
+export declare const DEFAULT_FILE_QUOTA_CLEANUP_BATCH = 100;
+/** Default deadline for resolving one request image through the Files API. */
+export declare const DEFAULT_FILES_API_TIMEOUT_MS = 60000;
+/**
+ * Map an HTTP status to a stable LlmError code.
+ * @param status - status of a non-2xx provider response.
+ * @param error - parsed provider error body, when available.
+ * @returns the normalized harness error code.
+ */
+export declare function httpErrorCode(status: number, error?: WireError['error']): string;
+/**
+ * The first real `LlmAdapter`. One instance serves every model name it was
+ * registered under (the harness model name IS the wire model name).
+ *
+ * One stable signal reaches both initial fetch and body reads. Caller aborts
+ * map to `ABORTED`; the configured per-read idle watchdog maps to `TIMEOUT`.
+ */
+export declare class DeepSeekAdapter extends LlmAdapter {
+    private readonly config;
+    private readonly files;
+    constructor(config: DeepSeekAdapterOptions);
+    providerInfo(provider: string): LlmProviderInfo;
+    providerRetryPolicy(_provider: string): ResolvedRetryPolicy;
+    imageRequestPricing(_provider: string, model: string): ReturnType<LlmAdapter['imageRequestPricing']>;
+    listModels(provider: string): Promise<readonly LlmModelInfo[]>;
+    resolveModel(provider: string, model: string, _signal?: AbortSignal): Promise<LlmResolvedModelInfo>;
+    private modelInfoFor;
+    prepareCall(provider: string, model: string, _signal?: AbortSignal): Promise<PreparedAdapterCall>;
+    stream(options: GenerateOptions): AsyncIterable<StreamChunk>;
+    private streamWithConnection;
+    private request;
+}
+//# sourceMappingURL=adapter.d.ts.map

package/vendor/deepseek/types/file-id.d.ts

@@ -0,0 +1,19 @@
+/** DeepSeek Files API identifiers. @module dsh-llm-deepseek/file-id */
+import type { Branded } from '@deepseek-ai/dsh-brand';
+/** Opaque identifier returned by the DeepSeek Files API. */
+export type DeepSeekFileId = Branded<'DeepSeekFileId'>;
+/**
+ * Brand a provider-returned file identifier after wire validation.
+ * @param id - non-empty Files API identifier.
+ * @returns the same string with its provider identity attached at type level.
+ */
+export declare function DeepSeekFileId(id: string): DeepSeekFileId;
+/** Non-secret digest identifying one endpoint and API-key file namespace. */
+export type DeepSeekFileScope = Branded<'DeepSeekFileScope'>;
+/**
+ * Brand a locally derived namespace digest.
+ * @param scope - SHA-256 digest of endpoint and API key.
+ * @returns the same string with namespace identity attached at type level.
+ */
+export declare function DeepSeekFileScope(scope: string): DeepSeekFileScope;
+//# sourceMappingURL=file-id.d.ts.map

package/vendor/deepseek/types/file-store.d.ts

@@ -0,0 +1,83 @@
+/** DeepSeek Files API upload reuse, invalidation, and quota recovery. @module dsh-llm-deepseek/file-store */
+import type { RequestImageAttachment } from '@deepseek-ai/dsh-attachment';
+import type { DeepSeekFileId } from './file-id.ts';
+import { DeepSeekUploadIndex } from './upload-index.ts';
+import type { DeepSeekUploadRecord } from './upload-index.ts';
+/** DeepSeek chat accepts at most 32 MiB per image even when it is referenced by file id. */
+export declare const MAX_CHAT_IMAGE_BYTES: number;
+/** Resolved file-store policy from the plugin configuration. */
+export interface DeepSeekFilePolicy {
+    expiresAfterSeconds: number;
+    refreshMarginSeconds: number;
+    quotaCleanupBatch: number;
+}
+/** Connection facts needed by file operations. */
+export interface DeepSeekFileConnection {
+    baseURL: string;
+    apiKey: string;
+}
+/** Result of one file-id resolution. */
+export interface DeepSeekFileReference {
+    record: DeepSeekUploadRecord;
+    uploaded: boolean;
+}
+interface FileStoreOptions {
+    index?: DeepSeekUploadIndex;
+    now?: () => number;
+    fetch?: typeof fetch;
+}
+/** User-scoped durable file-id reuse for the DeepSeek route. */
+export declare class DeepSeekFileStore {
+    private readonly index;
+    private readonly now;
+    private readonly fetchImpl;
+    private readonly inflight;
+    /**
+     * @param options - testable index, clock, and transport boundaries.
+     */
+    constructor(options?: FileStoreOptions);
+    private client;
+    /**
+     * Resolve or upload one deterministic request image. Concurrent calls share one upload while retaining independent waits.
+     * @param version - deterministic model-request bytes and complete transformation identity.
+     * @param connection - endpoint and API-key snapshot.
+     * @param policy - expiry and quota-recovery policy.
+     * @param signal - cancellation of this wait; shared transport stops when no waiter remains.
+     * @returns a reusable file id and whether this call published a new upload.
+     */
+    ensureUploaded(version: RequestImageAttachment, connection: DeepSeekFileConnection, policy: DeepSeekFilePolicy, signal?: AbortSignal): Promise<DeepSeekFileReference>;
+    private ensureUploadedOnce;
+    /**
+     * Invalidate one exact local mapping after the chat endpoint rejects its remote id.
+     * @param version - request-image version whose remote generation failed.
+     * @param fileId - exact rejected file id.
+     * @param connection - endpoint and API-key snapshot.
+     */
+    invalidate(version: RequestImageAttachment, fileId: DeepSeekFileId, connection: DeepSeekFileConnection): Promise<void>;
+    /**
+     * Delete the indexed remote file for one attachment and remove its local mapping.
+     * @param version - exact request-image version to release.
+     * @param connection - endpoint and API-key snapshot.
+     * @param policy - expiry policy used to locate a reusable mapping.
+     * @param signal - request cancellation.
+     * @returns whether an indexed file existed and was deleted.
+     */
+    release(version: RequestImageAttachment, connection: DeepSeekFileConnection, policy: DeepSeekFilePolicy, signal?: AbortSignal): Promise<boolean>;
+    /**
+     * Delete the oldest provider files whose names identify harness ownership.
+     * @param connection - endpoint and API-key snapshot.
+     * @param count - positive maximum number of files to delete.
+     * @param signal - request cancellation.
+     * @returns number of successfully deleted files.
+     */
+    reclaimOldestOwned(connection: DeepSeekFileConnection, count: number, signal?: AbortSignal): Promise<number>;
+    /**
+     * Delete every remote harness-owned file in the active API-key namespace and clear its index.
+     * @param connection - endpoint and API-key snapshot.
+     * @param signal - request cancellation.
+     * @returns number of deleted files.
+     */
+    releaseAll(connection: DeepSeekFileConnection, signal?: AbortSignal): Promise<number>;
+}
+export {};
+//# sourceMappingURL=file-store.d.ts.map

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

@@ -0,0 +1,103 @@
+/** OpenAI-compatible DeepSeek Files API transport. @module dsh-llm-deepseek/files-api */
+import { LlmError } from '@deepseek-ai/dsh-llm';
+import type { ImageMediaType } from '@deepseek-ai/dsh-attachment';
+import type { DeepSeekFileId as DeepSeekFileIdType } from './file-id.ts';
+/** Minimum provider-supported file lifetime. */
+export declare const MIN_FILE_EXPIRY_SECONDS = 3600;
+/** Maximum provider-supported file lifetime. */
+export declare const MAX_FILE_EXPIRY_SECONDS = 2592000;
+/** Maximum Files API upload size. */
+export declare const MAX_FILE_UPLOAD_BYTES: number;
+/** Current per-key file-count quota. */
+export declare const MAX_STORED_FILE_COUNT = 10000;
+/** Current per-key storage quota. */
+export declare const MAX_STORED_FILE_BYTES: number;
+/** Validated file object returned by the OpenAI-compatible endpoint. */
+export interface DeepSeekFileObject {
+    id: DeepSeekFileIdType;
+    bytes: number;
+    createdAt: number;
+    filename: string;
+    purpose: 'user_data';
+    expiresAt?: number;
+}
+/** One page returned by `GET /files`. */
+export interface DeepSeekFilePage {
+    data: DeepSeekFileObject[];
+    firstId?: DeepSeekFileIdType;
+    lastId?: DeepSeekFileIdType;
+    hasMore: boolean;
+}
+/** Files API operation failure with its HTTP status retained for recovery policy. */
+export declare class DeepSeekFilesError extends LlmError {
+    /** Parsed provider detail used only for error classification. */
+    readonly detail: string;
+    /**
+     * @param message - user-readable provider failure.
+     * @param status - HTTP status returned by the Files API.
+     * @param detail - provider error fields joined for classification.
+     */
+    constructor(message: string, status: number, detail: string);
+}
+/**
+ * Whether an upload failure reports a provider storage or file-count quota.
+ * @param error - Files API operation failure.
+ * @returns whether one bounded remote cleanup and upload retry may recover.
+ */
+export declare function isFilesQuotaError(error: unknown): error is DeepSeekFilesError;
+interface FilesApiOptions {
+    baseURL: string;
+    apiKey: string;
+    fetch?: typeof fetch;
+}
+/** Direct client for the OpenAI-compatible `/files` endpoints. */
+export declare class DeepSeekFilesClient {
+    private readonly baseURL;
+    private readonly apiKey;
+    private readonly fetchImpl;
+    /**
+     * @param options - endpoint, API-key snapshot, and optional test transport.
+     */
+    constructor(options: FilesApiOptions);
+    private request;
+    /**
+     * Upload one image with an explicit expiry.
+     * @param input - deterministic request-version bytes, media type, filename, lifetime, and cancellation.
+     * @returns the validated provider file object, including `expires_at`.
+     */
+    upload(input: {
+        data: Uint8Array;
+        mediaType: ImageMediaType;
+        filename: string;
+        expiresAfterSeconds: number;
+        signal?: AbortSignal;
+    }): Promise<DeepSeekFileObject & {
+        expiresAt: number;
+    }>;
+    /**
+     * List one ascending or descending page of user-data files.
+     * @param options - pagination, ordering, and cancellation.
+     * @returns the validated page.
+     */
+    list(options?: {
+        after?: DeepSeekFileIdType;
+        limit?: number;
+        order?: 'asc' | 'desc';
+        signal?: AbortSignal;
+    }): Promise<DeepSeekFilePage>;
+    /**
+     * Retrieve one file object.
+     * @param fileId - provider file identifier.
+     * @param signal - request cancellation.
+     * @returns the validated file object.
+     */
+    retrieve(fileId: DeepSeekFileIdType, signal?: AbortSignal): Promise<DeepSeekFileObject>;
+    /**
+     * Delete one provider file.
+     * @param fileId - provider file identifier.
+     * @param signal - request cancellation.
+     */
+    delete(fileId: DeepSeekFileIdType, signal?: AbortSignal): Promise<void>;
+}
+export {};
+//# sourceMappingURL=files-api.d.ts.map

package/vendor/deepseek/types/image-tokens.d.ts

@@ -0,0 +1,19 @@
+/**
+ * DeepSeek v4 vision-token accounting: the provider's published image-token
+ * calculator (api-docs.deepseek.com, Token & Token Usage) ported verbatim.
+ * The provider resizes every request image onto a 14px-patch grid, downsamples
+ * 3:1 per axis, and caps one image at 384 tokens; the port prices the
+ * pad-to-4 alignment at its 3-token upper bound because request pricing has
+ * no preceding-token position. Actual usage remains authoritative.
+ *
+ * @module dsh-llm-deepseek/image-tokens
+ */
+/**
+ * Vision tokens DeepSeek v4 charges for one request image of the given
+ * dimensions, at the worst-case alignment pad.
+ * @param width - positive integer request-image width in pixels.
+ * @param height - positive integer request-image height in pixels.
+ * @returns the provider vision-token price, at most 384.
+ */
+export declare function deepSeekImageTokens(width: number, height: number): number;
+//# sourceMappingURL=image-tokens.d.ts.map

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

@@ -0,0 +1,106 @@
+/**
+ * Register a {@link DeepSeekAdapter} for the `deepseek-official` provider route on
+ * `ctx.llm`, with connection facts resolved per request instead of frozen at
+ * load: the plugin layers its `cordis.yml` entry config under the optional
+ * `llm-deepseek` user-settings section (`ctx.settings`) and resolves the API
+ * key through the optional credential seam (`ctx.credentials`), so a changed
+ * base URL, catalog, or key reaches the very next request without restarting
+ * anything, while an in-flight stream keeps the facts it started with. The
+ * one registration-captured fact — the retry policy — re-registers the route
+ * in place when it changes.
+ * @module @deepseek-ai/dsh-llm-deepseek
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import z from '@deepseek-ai/schemastery';
+import type { RetryPolicyConfig } from '@deepseek-ai/dsh-llm';
+import { type LaunchEnvironmentSnapshot } from '@deepseek-ai/dsh-launch-environment';
+import type { DeepSeekCatalogModel, DeepSeekConnectionOptions } from './adapter.ts';
+export { DEFAULT_CONTEXT_WINDOW, DEFAULT_FILE_EXPIRY_SECONDS, DEFAULT_FILE_QUOTA_CLEANUP_BATCH, DEFAULT_FILE_REFRESH_MARGIN_SECONDS, DEFAULT_FILES_API_TIMEOUT_MS, DEFAULT_IMAGE_OFFLOAD_BYTE_QUANTUM, DEFAULT_IMAGE_OFFLOAD_COUNT_QUANTUM, DEFAULT_INLINE_IMAGE_OFFLOAD_BYTE_QUANTUM, DEFAULT_MAX_INLINE_REQUEST_IMAGE_BYTES, DEFAULT_MAX_TOKENS, DEFAULT_STREAM_IDLE_TIMEOUT_MS, DeepSeekAdapter, } from './adapter.ts';
+export type { DeepSeekAdapterOptions, DeepSeekCatalogModel, DeepSeekConnectionOptions } from './adapter.ts';
+export { DEFAULT_LOW_DETAIL_IMAGE_PIXEL_BUDGET, DEFAULT_MAX_IMAGES_PER_REQUEST, DEFAULT_MAX_REQUEST_FILES_BYTES, DEFAULT_REQUEST_IMAGE_MAX_BYTES, DEFAULT_REQUEST_IMAGE_PIXEL_BUDGET, deepSeekImageRequestPricing, resolveRequestImagePolicy, } from './request-pricing.ts';
+export { deepSeekImageTokens } from './image-tokens.ts';
+export { DeepSeekFileStore, MAX_CHAT_IMAGE_BYTES } from './file-store.ts';
+export type { DeepSeekFileConnection, DeepSeekFilePolicy, DeepSeekFileReference } from './file-store.ts';
+export { DeepSeekFilesClient, MAX_FILE_EXPIRY_SECONDS, MAX_FILE_UPLOAD_BYTES, MAX_STORED_FILE_BYTES, MAX_STORED_FILE_COUNT, MIN_FILE_EXPIRY_SECONDS } from './files-api.ts';
+export type { DeepSeekFileObject, DeepSeekFilePage } from './files-api.ts';
+export { DeepSeekFileId } from './file-id.ts';
+export type { DeepSeekFileId as DeepSeekFileIdType } from './file-id.ts';
+export { DeepSeekUploadIndex, deepSeekFileScope } from './upload-index.ts';
+export type { DeepSeekUploadRecord } from './upload-index.ts';
+export type { RequestDefaults } from './serialize.ts';
+export type * from './types.ts';
+export declare const name = "llm-deepseek";
+export declare const inject: string[];
+/**
+ * Plugin config, validated by the same-named schemastery schema and doubling
+ * as the `llm-deepseek` settings-section shape. Every field is optional in
+ * yml: a missing API key resolves through {@link Config.apiKeyEnv} at each
+ * request (a request without any key fails with `MISSING_CREDENTIAL`, not at
+ * plugin load), omitted thinking mode uses the provider default, and omitted
+ * reasoning effort resolves to `high`.
+ */
+export interface Config {
+    /** Credential reference (environment-variable name) resolved per request; defaults to `DEEPSEEK_API_KEY`. */
+    apiKeyEnv?: string;
+    /** Endpoint base; falls back to $DEEPSEEK_BASE_URL from a trusted environment layer, then the public API. */
+    baseURL?: string;
+    /** Deployment thinking policy; `disabled` limits every conversation request to `off`. */
+    thinking?: 'enabled' | 'disabled';
+    /** Default thinking effort (default `high`); `off` disables thinking per request. */
+    reasoningEffort?: 'off' | 'low' | 'high' | 'max';
+    /** Default per-request output cap (default 256,000); a model's own cap and explicit request values win. */
+    maxTokens?: number;
+    /** Positive context capacity used when the selected model has no exact value (default 1,000,000). */
+    defaultContextWindow?: number;
+    /** Advisory models shown by discovery consumers; defaults to V41 Flash, V4 Flash, V4 Pro, and V4 Flash Vision Exp. */
+    models?: DeepSeekCatalogModel[];
+    /** Maximum provider idle time while one stream read is outstanding (default five minutes). */
+    streamIdleTimeoutMs?: number;
+    /** Maximum accumulated file-referenced image bytes per chat request (default 128 MiB). */
+    maxRequestFilesBytes?: number;
+    /** Maximum accumulated base64 image payload after Files API fallback (default 20 MiB). */
+    maxInlineRequestImageBytes?: number;
+    /** Maximum number of represented images per chat request (default 600). */
+    maxImagesPerRequest?: number;
+    /** Raw-byte removal step after the request exceeds its file bound (default 64 MiB). */
+    imageOffloadByteQuantum?: number;
+    /** Base64-byte removal step after inline fallback exceeds its bound (default 10 MiB). */
+    inlineImageOffloadByteQuantum?: number;
+    /** Image-count removal step after the request exceeds its count bound (default 20). */
+    imageOffloadCountQuantum?: number;
+    /** Maximum duration of one request-image Files API resolution (default one minute). */
+    filesApiTimeoutMs?: number;
+    /** Explicit lifetime assigned to each uploaded image (default seven days). */
+    fileExpiresAfterSeconds?: number;
+    /** Remaining lifetime below which an indexed file is replaced (default one hour). */
+    fileRefreshMarginSeconds?: number;
+    /** Oldest harness-owned files deleted before one quota-recovery upload retry (default 100). */
+    fileQuotaCleanupBatch?: number;
+    /** Provider-owned model-request retry policy; omission uses normal mode with five retries. */
+    retryPolicy?: RetryPolicyConfig;
+}
+export declare const Config: z<Config>;
+/** Public API default; the internal endpoint comes from $DEEPSEEK_BASE_URL. */
+export declare const PUBLIC_BASE_URL = "https://api.deepseek.com";
+/**
+ * One resolution's complete request facts. Connection and credential facts
+ * are one value on purpose: a snapshot the resolver rejects keeps the whole
+ * previous generation, so a request can never pair a stale endpoint with a
+ * newer key.
+ */
+export type ResolvedDeepSeekOptions = DeepSeekConnectionOptions;
+/**
+ * The one explicit resolve step from raw config to validated connection
+ * facts. Programmatic construction may bypass Schemastery normalization, so
+ * every default and bound is re-judged here — for the composition entry at
+ * load (fail loud) and for each settings snapshot at its first use.
+ * @param config - raw plugin config or resolved settings snapshot.
+ * @param environment - this run's environment layers, or `undefined` outside
+ * the product CLI. Every layer may supply an endpoint: the product trusts the
+ * project it is launched in, so a checkout can point its own agent at the
+ * gateway that checkout is meant to use.
+ * @returns validated connection facts plus the credential reference.
+ */
+export declare function resolveAdapterOptions(config: Config, environment?: LaunchEnvironmentSnapshot): ResolvedDeepSeekOptions;
+export declare function apply(ctx: Context, config: Config): void;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,48 @@
+/**
+ * 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.
+ *
+ * @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';
+/** 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.
+ * @param model - Advertised model route and its optional image overrides.
+ * @returns Complete pixel and encoded-byte budgets.
+ * @internal
+ */
+export declare function resolveRequestImagePolicy(model: DeepSeekCatalogModel): ImageRequestPolicy;
+/**
+ * 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.
+ * @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.
+ * @returns synchronous per-occurrence pricing for the route.
+ */
+export declare function deepSeekImageRequestPricing(connection: DeepSeekConnectionOptions, model: string, resolveAccess?: ImageAttachmentAccessResolver): LlmImageRequestPricing;
+//# sourceMappingURL=request-pricing.d.ts.map

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

@@ -0,0 +1,85 @@
+/**
+ * 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';
+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.
+ */
+export declare function serializeRequestWithImages(options: GenerateOptions, images: ImageSerializationOptions, defaults?: RequestDefaults): Promise<WireRequest>;
+//# sourceMappingURL=serialize.d.ts.map

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

@@ -0,0 +1,24 @@
+/**
+ * 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
+ */
+/** 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>;
+//# sourceMappingURL=sse.d.ts.map