@stackstackstack/dsh-llm-deepseek 0.1.5

package/lib/invariant.js

@@ -0,0 +1,23 @@
+//#region lib/types/invariant.js
+/**
+* Package-owned invariant companion for `@stackstackstack/dsh-llm-deepseek`.
+* @module @stackstackstack/dsh-llm-deepseek/invariant
+*/
+const PACKAGE_NAME = "@stackstackstack/dsh-llm-deepseek";
+/** Cordis companion plugin name. */
+const name = "llm-deepseek-invariant";
+/** Service required before the companion can reserve package ownership. */
+const inject = ["invariants"];
+/**
+* No runtime invariant: this package exposes no independent event sequence or mutable data relation
+* beyond contracts enforced at its owning seam.
+*/
+const install = () => {};
+/**
+* Register this package's invariant companion.
+* @param ctx - Cordis context carrying the invariant service.
+* @returns the installed registration's disposer after setup succeeds.
+*/
+const apply = (ctx) => Promise.resolve(ctx.invariants.register(PACKAGE_NAME, install));
+//#endregion
+export { apply, inject, name };

package/lib/types/adapter.d.ts

@@ -0,0 +1,102 @@
+/**
+ * `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 '@stackstackstack/dsh-llm';
+import type { GenerateOptions, LlmModelInfo, LlmProviderInfo, LlmResolvedModelInfo, ResolvedRetryPolicy, StreamChunk } from '@stackstackstack/dsh-llm';
+import type { CredentialRef } from '@stackstackstack/dsh-credentials';
+import type { AnonymousUserId } from '@stackstackstack/dsh-anonymous-user-id';
+import type { RequestDefaults } from './serialize.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;
+}
+/**
+ * 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;
+    /** 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;
+}
+/** 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;
+/**
+ * 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;
+    constructor(config: DeepSeekAdapterOptions);
+    providerInfo(provider: string): LlmProviderInfo;
+    providerRetryPolicy(_provider: string): ResolvedRetryPolicy;
+    listModels(provider: string): Promise<readonly LlmModelInfo[]>;
+    resolveModel(provider: string, model: string, _signal?: AbortSignal): Promise<LlmResolvedModelInfo>;
+    stream(options: GenerateOptions): AsyncIterable<StreamChunk>;
+    private request;
+}
+//# sourceMappingURL=adapter.d.ts.map

package/lib/types/index.d.ts

@@ -0,0 +1,76 @@
+/**
+ * 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 @stackstackstack/dsh-llm-deepseek
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import z from '@deepseek-ai/schemastery';
+import type { RetryPolicyConfig } from '@stackstackstack/dsh-llm';
+import { type LaunchEnvironmentSnapshot } from '@stackstackstack/dsh-launch-environment';
+import type { DeepSeekCatalogModel, DeepSeekConnectionOptions } from './adapter.ts';
+export { DEFAULT_CONTEXT_WINDOW, DEFAULT_MAX_TOKENS, DEFAULT_STREAM_IDLE_TIMEOUT_MS, DeepSeekAdapter, } from './adapter.ts';
+export type { DeepSeekAdapterOptions, DeepSeekCatalogModel, DeepSeekConnectionOptions } from './adapter.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' | '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 V4 Flash and V4 Pro. */
+    models?: DeepSeekCatalogModel[];
+    /** Maximum provider idle time while one stream read is outstanding (default five minutes). */
+    streamIdleTimeoutMs?: number;
+    /** Provider-owned model-request retry policy; omission uses normal defaults. */
+    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/lib/types/invariant.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Package-owned invariant companion for `@stackstackstack/dsh-llm-deepseek`.
+ * @module @stackstackstack/dsh-llm-deepseek/invariant
+ */
+import type { Context } from '@deepseek-ai/cordis';
+/** Cordis companion plugin name. */
+export declare const name = "llm-deepseek-invariant";
+/** Service required before the companion can reserve package ownership. */
+export declare const inject: string[];
+/**
+ * Register this package's invariant companion.
+ * @param ctx - Cordis context carrying the invariant service.
+ * @returns the installed registration's disposer after setup succeeds.
+ */
+export declare const apply: (ctx: Context) => Promise<() => void>;
+//# sourceMappingURL=invariant.d.ts.map

package/lib/types/serialize.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Serialize harness messages into DeepSeek chat completions. User text is joined; assistant text
+ * becomes `content`, tool calls become `tool_calls`, and tool results become separate tool messages.
+ * Assistant reasoning is replayed as `reasoning_content` only on tool-call turns, as required by
+ * thinking-mode passback. Core image blocks are rejected explicitly because this wire route is text-only;
+ * unknown declaration-merged block types retain the adapter's documented extension fallback.
+ * @module dsh-llm-deepseek/serialize
+ */
+import type { GenerateOptions, Message } from '@stackstackstack/dsh-llm';
+import type { WireMessage, WireRequest } from './types.ts';
+/** Adapter-level request defaults (from plugin config). */
+export interface RequestDefaults {
+    thinking?: 'enabled' | 'disabled' | undefined;
+    reasoningEffort?: 'off' | 'high' | 'max' | undefined;
+}
+/**
+ * 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[];
+/**
+ * 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;
+//# sourceMappingURL=serialize.d.ts.map

package/lib/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

package/lib/types/translate.d.ts

@@ -0,0 +1,36 @@
+/**
+ * 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 '@stackstackstack/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; cache/reasoning fields present only when the wire reported them.
+ */
+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/lib/types/types.d.ts

@@ -0,0 +1,150 @@
+/**
+ * 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; low/medium map to high server-side). */
+    reasoning_effort?: '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;
+}
+/** User-role message: a single string of user input. */
+export interface WireUserMessage {
+    role: 'user';
+    content: string;
+}
+/** 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. REQUIRED on assistant turns that carried tool calls
+     * (thinking mode); ignored on tool-call-free turns (we omit it there to
+     * save tokens). See guides/thinking_mode.mdx § Tool Calls.
+     */
+    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;
+    /** Present on the first delta of each call only. */
+    id?: string;
+    type?: 'function';
+    function?: {
+        /** Present on the first delta of each call only. */
+        name?: string;
+        /** Argument JSON fragment (concatenate across deltas). */
+        arguments?: string;
+    };
+}
+/**
+ * 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;
+    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/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "@stackstackstack/dsh-llm-deepseek",
+  "description": "DeepSeek chat-completions adapter for the DeepSeek Harness LLM seam",
+  "version": "0.1.5",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/deepseek-ai/deepseek-harness.git",
+    "directory": "packages/llm/llm-deepseek"
+  },
+  "type": "module",
+  "main": "lib/index.js",
+  "types": "lib/types/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./lib/types/index.d.ts",
+      "default": "./lib/index.js"
+    },
+    "./invariant": {
+      "types": "./lib/types/invariant.d.ts",
+      "default": "./lib/invariant.js"
+    },
+    "./src/*": "./src/*",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "lib/index.js",
+    "lib/invariant.js",
+    "lib/types/**/*.d.ts"
+  ],
+  "license": "MIT",
+  "peerDependencies": {
+    "@stackstackstack/dsh-credentials": "^0.1.5",
+    "@stackstackstack/dsh-llm": "^0.1.5",
+    "@stackstackstack/dsh-invariants": "^0.1.5",
+    "@stackstackstack/dsh-timeout": "^0.1.5",
+    "@deepseek-ai/cordis": "^4.0.1",
+    "@stackstackstack/dsh-settings": "^0.1.5",
+    "@stackstackstack/dsh-launch-environment": "^0.1.5",
+    "@stackstackstack/dsh-anonymous-user-id": "^0.1.5"
+  },
+  "dependencies": {
+    "eventsource-parser": "^3.1.0",
+    "@deepseek-ai/schemastery": "^3.18.1"
+  },
+  "devDependencies": {
+    "@stackstackstack/dsh-credentials": "^0.1.5",
+    "@stackstackstack/dsh-launch-environment": "^0.1.5",
+    "@stackstackstack/dsh-settings": "^0.1.5",
+    "@stackstackstack/dsh-llm": "^0.1.5",
+    "@stackstackstack/dsh-invariants": "^0.1.5",
+    "@stackstackstack/dsh-anonymous-user-id": "^0.1.5",
+    "@stackstackstack/dsh-timeout": "^0.1.5",
+    "@deepseek-ai/cordis": "^4.0.1"
+  }
+}