@toddzheng024/dscode-bundle 0.1.0

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

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

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

@@ -0,0 +1,178 @@
+/**
+ * DeepSeek chat-completions wire format (OpenAI-compatible). Types only.
+ *
+ * Source of truth: the official API docs at
+ * `~/repos/deepsuite-docs/apps/docs/docs` (api/create-chat-completion,
+ * guides/thinking_mode.mdx, guides/tool_calls.md), cross-checked against
+ * live streams from the internal endpoint (2026-06).
+ *
+ * @module dsh-llm-deepseek/types
+ */
+/** Request body for `POST {baseURL}/chat/completions`. */
+export interface WireRequest {
+    model: string;
+    messages: WireMessage[];
+    stream: true;
+    stream_options: {
+        include_usage: true;
+    };
+    /** Thinking-mode toggle (top level, NOT inside extra_body on the wire). */
+    thinking?: {
+        type: 'enabled' | 'disabled';
+    };
+    /** Thinking effort (official levels). */
+    reasoning_effort?: 'low' | 'high' | 'max';
+    tools?: WireTool[];
+    temperature?: number;
+    max_tokens?: number;
+    /**
+     * Stop sequences (OpenAI `stop`): generation halts as soon as the model
+     * produces any one of these strings. Mapped from `GenerateOptions.stop`.
+     */
+    stop?: string[];
+}
+/** System-role message: a single string of instructions. */
+export interface WireSystemMessage {
+    role: 'system';
+    content: string;
+}
+/** Text part inside a multimodal user message. */
+export interface WireTextContentPart {
+    type: 'text';
+    text: string;
+}
+/** Files API reference inside a multimodal user message. */
+export interface WireFileContentPart {
+    type: 'file';
+    file_id: string;
+}
+/** Inline base64 data URL inside a multimodal user message. */
+export interface WireImageUrlContentPart {
+    type: 'image_url';
+    image_url: {
+        url: string;
+    };
+}
+/** One image representation accepted by a multimodal user message. */
+export type WireImageContentPart = WireFileContentPart | WireImageUrlContentPart;
+/** Ordered input part accepted by a multimodal user message. */
+export type WireUserContentPart = WireTextContentPart | WireImageContentPart;
+/** User-role message: text-only string or ordered multimodal input. */
+export interface WireUserMessage {
+    role: 'user';
+    content: string | WireUserContentPart[];
+}
+/** Tool-role message: the result of one tool call, keyed by its call id. */
+export interface WireToolMessage {
+    role: 'tool';
+    tool_call_id: string;
+    content: string;
+}
+/** One entry of the request `messages` array, discriminated on `role`. */
+export type WireMessage = WireSystemMessage | WireUserMessage | WireAssistantMessage | WireToolMessage;
+/**
+ * Assistant-role history message. The harness replays `content: ""` (never
+ * null) on tool-call-only turns — some gateways reject null — and sends null
+ * only when the turn carried neither text nor tool calls.
+ */
+export interface WireAssistantMessage {
+    role: 'assistant';
+    content: string | null;
+    /**
+     * CoT passback, present on every turn whose assistant content carried
+     * reasoning. REQUIRED on tool-call turns in thinking mode (see
+     * guides/thinking_mode.mdx § Tool Calls); DeepSeek ignores it elsewhere,
+     * while a gateway re-encoding for another vendor recovers that turn's
+     * thinking signature by hashing it.
+     */
+    reasoning_content?: string;
+    tool_calls?: WireToolCall[];
+}
+/** A completed tool call replayed on an assistant history message; `arguments` is the raw JSON string. */
+export interface WireToolCall {
+    id: string;
+    type: 'function';
+    function: {
+        name: string;
+        arguments: string;
+    };
+}
+/** One entry of the request `tools` array; `parameters` is a JSON Schema object. */
+export interface WireTool {
+    type: 'function';
+    function: {
+        name: string;
+        description: string;
+        parameters: Record<string, unknown>;
+    };
+}
+/** One parsed SSE `data:` payload (a chat.completion.chunk). */
+export interface WireChunk {
+    choices?: WireChoice[];
+    /** Arrives attached to the finish chunk and/or as a trailing usage-only chunk. */
+    usage?: WireUsage | null;
+}
+/** One streamed choice (requests always ask for a single one); `finish_reason` is non-null only on its terminal chunk. */
+export interface WireChoice {
+    delta?: WireDelta;
+    finish_reason?: string | null;
+}
+/** The incremental content of one streamed choice; any subset of fields may be present per chunk. */
+export interface WireDelta {
+    role?: string;
+    /** Visible text. Null/empty on reasoning/tool-call chunks. */
+    content?: string | null;
+    /**
+     * Thinking-mode CoT. The FIRST chunk carries an empty string (must not
+     * open a reasoning block); absent entirely in non-thinking mode.
+     */
+    reasoning_content?: string | null;
+    tool_calls?: WireToolCallDelta[];
+}
+/** A streamed fragment of one tool call; fragments sharing an `index` concatenate into one call. */
+export interface WireToolCallDelta {
+    /** Disambiguates parallel tool calls; stable across a call's deltas. */
+    index: number;
+    /**
+     * Carried by the first delta of each call. Gateways observed in the wild
+     * repeat it on continuation deltas as `''` or `null`; both mean "unchanged".
+     */
+    id?: string | null;
+    type?: 'function';
+    function?: {
+        /** Carried by the first delta of each call, with the same `''`/`null` repetition as {@link WireToolCallDelta.id}. */
+        name?: string | null;
+        /** Argument JSON fragment (concatenate across deltas). */
+        arguments?: string | null;
+    };
+}
+/**
+ * Wire token accounting. `prompt_tokens` INCLUDES cache hits (it equals
+ * `prompt_cache_hit_tokens + prompt_cache_miss_tokens`); `mapUsage` subtracts
+ * them to keep the harness convention of disjoint counts.
+ * `prompt_tokens_details.cached_tokens` is the OpenAI-compat spelling of the
+ * hit count.
+ */
+export interface WireUsage {
+    prompt_tokens: number;
+    completion_tokens: number;
+    /** Provider-reported aggregate across prompt and completion tokens. */
+    total_tokens?: number;
+    prompt_cache_hit_tokens?: number;
+    prompt_cache_miss_tokens?: number;
+    prompt_tokens_details?: {
+        cached_tokens?: number;
+    };
+    completion_tokens_details?: {
+        reasoning_tokens?: number;
+    };
+}
+/** Non-2xx error body. */
+export interface WireError {
+    error?: {
+        message?: string;
+        type?: string;
+        code?: string;
+    };
+}
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1,68 @@
+/** Durable DeepSeek attachment-to-file-id index. @module dsh-llm-deepseek/upload-index */
+import type { AttachmentId, ImageVariantId as ImageVariantIdType } from '@deepseek-ai/dsh-attachment';
+import type { DeepSeekFileId as DeepSeekFileIdType, DeepSeekFileScope as DeepSeekFileScopeType } from './file-id.ts';
+/** One durable remote upload mapping. Unix times are milliseconds. */
+export interface DeepSeekUploadRecord {
+    scope: DeepSeekFileScopeType;
+    /** Provider-independent normalized attachment from which the uploaded request version was derived. */
+    attachmentId: AttachmentId;
+    /** Complete request transformation identity, including route budgets and encoder parameters. */
+    variantId: ImageVariantIdType;
+    fileId: DeepSeekFileIdType;
+    bytes: number;
+    createdAt: number;
+    expiresAt: number;
+}
+/** Candidate commit outcome when another process already published a reusable upload. */
+export interface UploadIndexCommit {
+    record: DeepSeekUploadRecord;
+    accepted: boolean;
+}
+/**
+ * Derive a non-secret stable index namespace without persisting or logging the API key.
+ * @param baseURL - normalized provider endpoint namespace.
+ * @param apiKey - resolved credential used only as hash input.
+ * @returns branded SHA-256 namespace digest.
+ */
+export declare function deepSeekFileScope(baseURL: string, apiKey: string): DeepSeekFileScopeType;
+/** Atomic local index shared by every DeepSeek session in this DSH home. */
+export declare class DeepSeekUploadIndex {
+    /** Absolute owner-private JSON index path. */
+    readonly path: string;
+    /**
+     * @param path - explicit test path; omission uses `DSH_HOME/llm-deepseek/files-v3.json`.
+     */
+    constructor(path?: string);
+    private load;
+    private save;
+    /**
+     * Read one reusable mapping.
+     * @param scope - endpoint/API-key namespace.
+     * @param variantId - complete request-image transformation identity.
+     * @param now - current Unix time in milliseconds.
+     * @param refreshMarginMs - remaining lifetime below which a mapping is not reused.
+     * @returns the mapping when it has enough lifetime remaining.
+     */
+    get(scope: DeepSeekFileScopeType, variantId: ImageVariantIdType, now: number, refreshMarginMs: number): Promise<DeepSeekUploadRecord | undefined>;
+    /**
+     * Publish a completed upload unless another process already published a reusable mapping.
+     * @param candidate - completed remote upload.
+     * @param now - current Unix time in milliseconds.
+     * @param refreshMarginMs - minimum reusable remaining lifetime.
+     * @returns the winning record and whether the candidate entered the index.
+     */
+    commit(candidate: DeepSeekUploadRecord, now: number, refreshMarginMs: number): Promise<UploadIndexCommit>;
+    /**
+     * Remove one exact mapping without deleting a concurrently installed successor.
+     * @param scope - endpoint/API-key namespace.
+     * @param variantId - complete request-image transformation identity.
+     * @param fileId - exact remote generation being invalidated.
+     */
+    remove(scope: DeepSeekFileScopeType, variantId: ImageVariantIdType, fileId: DeepSeekFileIdType): Promise<void>;
+    /**
+     * Remove every local mapping for one remote namespace.
+     * @param scope - endpoint/API-key namespace.
+     */
+    clear(scope: DeepSeekFileScopeType): Promise<void>;
+}
+//# sourceMappingURL=upload-index.d.ts.map

package/vendor/persistent/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 DeepSeek
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.