@eddyskywalker/dsh-chatgpt-subscription 0.2.21 → 0.3.1

package/lib/types/host/kimi-code/mapper.d.ts

@@ -0,0 +1,370 @@
+/**
+ * Provider-wire mapping for the Kimi Code coding endpoints.
+ *
+ * Two surfaces serve the same models:
+ *
+ * - the OpenAI-compatible `/coding/v1/chat/completions`, which is what the
+ *   official CLI configures for its managed provider and therefore the default
+ *   here; and
+ * - the Anthropic-compatible `/coding/v1/messages?beta=true`, which authenticates
+ *   with `x-api-key` rather than a bearer token.
+ *
+ * Both are mapped here, and both streams are normalized into DSH's block/delta
+ * vocabulary.
+ *
+ * Two Kimi-specific behaviours shape the request builders:
+ *
+ * 1. Thinking is selected with `reasoning_effort` and accepts only
+ *    low/high/max; anything else the client sends is answered with HTTP 400, so
+ *    a caller's broader effort vocabulary is narrowed here rather than passed
+ *    through. Thinking off is expressed as `thinking: {type: "disabled"}`.
+ * 2. When thinking is on, Kimi requires `reasoning_content` on an assistant
+ *    message that also carries tool calls — the service answers 400
+ *    "thinking is enabled but reasoning_content is missing" otherwise. Reasoning
+ *    blocks are therefore replayed on the OpenAI wire, unlike the sibling routes
+ *    which drop them.
+ *
+ * See https://www.kimi.com/code/docs/en/kimi-code/error-reference.html
+ */
+import { type ContentBlock, type GenerateOptions, type Message, type StreamChunk } from '@deepseek-ai/dsh-llm';
+import type { AttachmentStore } from '@deepseek-ai/dsh-attachment';
+import { type VideoAttachmentRef } from './modalities.ts';
+import type { KimiCodeReasoningEffort, KimiCodeWire } from '../../shared/kimi-code-contracts.ts';
+/**
+ * Kimi caps a tool-call id at 64 characters and rejects a longer one.
+ *
+ * DSH ids are usually short, but a provider that prefixes them with a session
+ * or turn marker can exceed the bound, so a long id is truncated
+ * deterministically rather than allowed to fail the whole request.
+ */
+export declare function clampToolCallId(id: string): string;
+/**
+ * Service limits on the request shape, from the official error reference.
+ *
+ * Both were documented as hard 400s, so exceeding them costs the whole turn
+ * rather than degrading gracefully — which is why the request is trimmed to fit
+ * instead of being sent and rejected.
+ */
+export declare const MAX_STOP_SEQUENCES = 5;
+export declare const MAX_STOP_SEQUENCE_BYTES = 32;
+/**
+ * Whether one request asks the service to keep reasoning across turns.
+ *
+ * Kimi's models reason by default and the official CLI ships Preserved Thinking
+ * ON (`[thinking] keep = "all"`), which is what its own error reference assumes
+ * when it demands `reasoning_content` on every assistant message. An
+ * environment opt-out exists for a deployment that would rather not pay for the
+ * replayed reasoning tokens.
+ */
+export declare function preserveThinkingEnabled(env?: NodeJS.ProcessEnv): boolean;
+/**
+ * Trim stop sequences to what the service accepts.
+ *
+ * At most five entries, each at most 32 bytes; a longer sequence is dropped
+ * rather than truncated, because a shortened stop string would halt generation
+ * at the wrong place — silently changing the answer is worse than not stopping.
+ */
+export declare function stopSequences(stop: readonly string[] | undefined): string[];
+/**
+ * Narrow a caller's effort onto the levels Kimi accepts.
+ *
+ * DSH exposes low/high/max/none for these models, but a conversation can hold
+ * an effort chosen for a different provider, so the broader vocabulary the rest
+ * of the plugin uses is mapped rather than rejected: an unknown value would be
+ * answered with HTTP 400 and fail the turn.
+ */
+export declare function mapReasoningEffort(effort: string | undefined | null): KimiCodeReasoningEffort | undefined;
+/**
+ * Thinking-token budget one Anthropic-route level asks for.
+ *
+ * Kimi's Anthropic surface takes the standard `thinking` block, so the budget is
+ * derived from the same three levels the OpenAI surface uses.
+ */
+export declare function thinkingBudgetFor(effort: KimiCodeReasoningEffort | undefined, maxTokens: number): number | undefined;
+/** Attachment seam this route needs: verified bytes for one durable image. */
+export type AttachmentImageReader = Pick<AttachmentStore, 'readImage'>;
+/** One durable user image resolved for an in-flight request, or proven unreadable. */
+export type ResolvedRequestImage = {
+    readonly kind: 'inline';
+    readonly mediaType: string;
+    readonly data: string;
+} | {
+    readonly kind: 'unavailable';
+};
+/** Resolved images keyed by durable attachment id; consumed by one request build. */
+export type ResolvedRequestImages = ReadonlyMap<string, ResolvedRequestImage>;
+/**
+ * Base64 image payload one request may carry.
+ *
+ * Kimi rejects a request whose total message size exceeds 2 MB with a 400, and
+ * the image bytes share that budget with the conversation text, tool schemas,
+ * and system prompt — so the bound is deliberately the smaller of the two
+ * documented limits rather than the largest body the transport would accept.
+ */
+export declare const MAX_REQUEST_IMAGE_BYTES = 1500000;
+/** Message-body ceiling the service documents for one request. */
+export declare const MAX_MESSAGE_BODY_BYTES = 2097152;
+/**
+ * Body ceiling once a request carries video.
+ *
+ * The 2 MB figure above is the documented limit for text and images, and it is
+ * far too small for video: a single frame-sequence clip dwarfs it. Kimi's own
+ * video guidance carries a separate, much larger request budget, so the ceiling
+ * is raised only for a request that actually attaches video. A text-only or
+ * image-only request keeps the tighter guard, because catching that 400 locally
+ * is the whole reason it exists.
+ */
+export declare const MAX_VIDEO_MESSAGE_BODY_BYTES: number;
+/**
+ * Base64 video budget for one request.
+ *
+ * Deliberately below {@link MAX_VIDEO_MESSAGE_BODY_BYTES} so the surrounding
+ * JSON envelope, tool schemas and text still fit; the oldest clips are dropped
+ * first once the total would exceed it.
+ */
+export declare const MAX_REQUEST_VIDEO_BYTES: number;
+/**
+ * Replace the oldest inline images with a text placeholder once one request
+ * would carry more than {@link MAX_REQUEST_IMAGE_BYTES} of base64 image data.
+ * Durable history is untouched; only the request about to be sent changes.
+ */
+export declare function offloadOldestRequestImages(options: GenerateOptions): GenerateOptions;
+/**
+ * Read every durable `{ type: 'image', attachment }` block one request carries.
+ * An unreadable image resolves to `unavailable` rather than disappearing, so
+ * the model is told the picture is missing instead of answering about a blank.
+ */
+export declare function resolveRequestImages(options: GenerateOptions, attachments: AttachmentImageReader | undefined, signal?: AbortSignal): Promise<ResolvedRequestImages>;
+/**
+ * One durable video resolved for an in-flight request, or proven unreadable.
+ *
+ * The shape mirrors {@link ResolvedRequestImage} so the two media kinds travel
+ * the same path and differ only in the wire part each produces.
+ */
+export type ResolvedRequestVideo = {
+    readonly kind: 'inline';
+    readonly mediaType: string;
+    readonly data: string;
+} | {
+    readonly kind: 'unavailable';
+};
+/** Resolved videos keyed by attachment id; consumed by one request build. */
+export type ResolvedRequestVideos = ReadonlyMap<string, ResolvedRequestVideo>;
+/**
+ * Attachment seam for video bytes.
+ *
+ * DSH's own attachment service stores images only, so a video reference can
+ * only exist if some producer in this deployment created it. Rather than
+ * pretend otherwise, the reader is an injected seam: absent means every video
+ * resolves to `unavailable` and the model is told the clip is missing, which is
+ * strictly better than silently sending a request with no video at all.
+ */
+export type AttachmentVideoReader = {
+    readVideo(ref: VideoAttachmentRef, signal?: AbortSignal): Promise<{
+        data: Uint8Array;
+        mediaType: string;
+    }>;
+};
+/**
+ * Drop the oldest videos once one request would carry more than
+ * {@link MAX_REQUEST_VIDEO_BYTES} of base64 video data, replacing each with a
+ * text placeholder. Durable history is untouched; only the request about to be
+ * sent changes. Images are left alone — they have their own, much smaller
+ * budget and their own offload pass.
+ */
+export declare function offloadOldestRequestVideos(options: GenerateOptions): GenerateOptions;
+/**
+ * Read every durable `{ type: 'video', attachment }` block one request carries.
+ * An unreadable clip resolves to `unavailable` rather than disappearing, so the
+ * model is told the video is missing instead of answering about a blank.
+ */
+export declare function resolveRequestVideos(options: GenerateOptions, attachments: AttachmentVideoReader | undefined, signal?: AbortSignal): Promise<ResolvedRequestVideos>;
+/** True when the request carries any video occurrence at all. */
+export declare function requestHasVideo(options: GenerateOptions): boolean;
+/**
+ * Media a single request build may carry.
+ *
+ * Passed as one object so adding a media kind never grows a positional
+ * signature the existing callers already bind.
+ */
+export interface RequestMediaOptions {
+    /** Videos read for this request; absent means none are readable. */
+    videos?: ResolvedRequestVideos;
+    /** Whether the selected model declares video input. */
+    videoAccepted?: boolean;
+    /**
+     * Whether the selected model accepts message-level tool declarations
+     * (`messages[].tools`), Kimi's `dynamically_loaded_tools` capability.
+     */
+    messageTools?: boolean;
+}
+/** Drop the JSON-Schema keywords provider gateways reject or ignore. */
+export declare function stripMetaSchema(schema: unknown): Record<string, unknown>;
+/**
+ * One complete tool definition, in the shape the function-calling wire wants.
+ *
+ * The service rejects a bare tool name: a message-level declaration must carry
+ * the same name/description/parameters triple the top-level list carries, so
+ * the caller cannot pass a reference and let the model guess.
+ */
+export interface DynamicToolDeclaration {
+    name: string;
+    description: string;
+    parameters: Record<string, unknown>;
+}
+/**
+ * A tool declaration that belongs to a message rather than the request.
+ *
+ * DSH has no message-level tool field, so the producer sets this symbol on a
+ * system-role {@link Message} to ask for one. A symbol is used rather than a
+ * string key because every other reader of a message — the session log, the
+ * transcript UI, another adapter — must not start seeing a field it cannot
+ * honor; the property is invisible to them and only this mapper looks for it.
+ */
+export declare const MESSAGE_TOOLS: unique symbol;
+/**
+ * Serializable key the declaration travels under.
+ *
+ * A symbol alone is not enough: the session log persists messages through
+ * JSON, which drops symbol-keyed properties, so a restored session would lose
+ * every declaration and the model would believe it had tools the request no
+ * longer carries. The declaration is therefore stored under a plain string key
+ * AND the symbol, so in-process readers keep the exempt-from-`Object.keys`
+ * behaviour while a round trip through persistence still reconstructs it.
+ */
+export declare const MESSAGE_TOOLS_KEY = "kimiCodeMessageTools";
+/**
+ * Attach message-level tool declarations to one system message.
+ *
+ * Two copies are written deliberately, and they differ in visibility:
+ *
+ * - the SYMBOL copy is non-enumerable, so a reader that inspects a message the
+ *   ordinary way (the transcript UI, a sibling adapter) sees nothing new and
+ *   cannot mistake an unhandled field for something it must act on;
+ * - the STRING-KEYED copy is enumerable, because JSON persistence only
+ *   serializes enumerable string keys and a declaration that vanishes on
+ *   session resume is worse than one that is visible. Readers that do walk the
+ *   keys will see `kimiCodeMessageTools`; the convention is that only this
+ *   route's mapper interprets it.
+ */
+export declare function withMessageTools<T extends Message>(message: T, tools: readonly DynamicToolDeclaration[]): T;
+/** Message-level tool declarations one message carries, when any. */
+export declare function messageToolsOf(message: Message): readonly DynamicToolDeclaration[] | undefined;
+/**
+ * Re-attach declarations after a message has been through JSON.
+ *
+ * Persistence keeps the declarations but necessarily loses the symbol, so a
+ * restored message exposes them only under {@link MESSAGE_TOOLS_KEY}. This
+ * restores the symbol too, which is what makes a declaration survive a resumed
+ * session instead of silently disappearing.
+ */
+export declare function rehydrateMessageTools<T extends Message>(message: T): T;
+/**
+ * Rough prompt size for one request, in tokens.
+ *
+ * Derived from the serialized text with the usual ~4 characters per token
+ * heuristic. It is deliberately an estimate: the purpose is only to keep
+ * `max_tokens` from making a request the service will reject outright, and the
+ * service's own count remains authoritative. Undefined is returned for an empty
+ * request so the caller leaves the cap alone rather than clamping against zero.
+ */
+export declare function estimatedInputTokens(options: GenerateOptions): number | undefined;
+/** Build one `/chat/completions` body. */
+export declare function buildOpenAIRequest(options: GenerateOptions, images?: ResolvedRequestImages, preserveThinking?: boolean, media?: RequestMediaOptions): Record<string, unknown>;
+/**
+ * Stable identifier for the conversation this request belongs to.
+ *
+ * Derived from the first user turn rather than a fresh value per request, so it
+ * stays identical across the steps of one session and changes when a new
+ * conversation starts.
+ */
+export declare function promptCacheKey(options: GenerateOptions): string | undefined;
+/** Build one `/v1/messages` body. */
+export declare function buildAnthropicRequest(options: GenerateOptions, images?: ResolvedRequestImages, _media?: RequestMediaOptions): Record<string, unknown>;
+/** Build the body for whichever endpoint serves `wire`. */
+export declare function buildRequest(options: GenerateOptions, wire: KimiCodeWire, images?: ResolvedRequestImages, preserveThinking?: boolean, media?: RequestMediaOptions): Record<string, unknown>;
+/**
+ * Reject a request the service would answer with its 2 MB body 400.
+ *
+ * This is the most frequently reported 400 on the coding endpoint, and it is
+ * worth catching locally for two reasons: the message can name the actual
+ * remedy (DSH's compaction), and a request that cannot succeed should not be
+ * sent at all. The measured size is the real serialized body, so it accounts
+ * for tool schemas and inlined images the caller cannot easily estimate.
+ *
+ * @returns the serialized body, so a caller that is about to send it does not
+ * serialize a body of up to tens of megabytes a second time.
+ */
+export declare function assertRequestBodyFits(body: Record<string, unknown>, carriesVideo?: boolean): string;
+/** One tool call accumulating across `chat/completions` deltas. */
+interface PendingToolCall {
+    blockIndex: number;
+    id: string;
+    name: string;
+    arguments: string;
+    started: boolean;
+}
+export interface KimiCodeStreamState {
+    wire: KimiCodeWire;
+    blocks: ContentBlock[];
+    current: {
+        index: number;
+        type: 'text' | 'reasoning';
+        text: string;
+    } | null;
+    /** wire tool index -> accumulating call (OpenAI route). */
+    toolCalls: Map<number, PendingToolCall>;
+    /** anthropic content-block index -> our block index. */
+    contentIndexes: Map<number, number>;
+    /** anthropic content index of the block currently open. */
+    openContentIndex: number | null;
+    hasContent: boolean;
+    hasToolCall: boolean;
+    finishReason: string | null;
+    done: boolean;
+    finished: boolean;
+    inputTokens: number;
+    outputTokens: number;
+    cacheReadTokens: number;
+    cacheWriteTokens: number;
+    reasoningTokens: number;
+    sawUsage: boolean;
+}
+export declare function createStreamState(wire: KimiCodeWire): KimiCodeStreamState;
+/** Feed one SSE `data:` payload from `/chat/completions`. */
+export declare function processOpenAIStreamLine(line: string, state: KimiCodeStreamState): StreamChunk[];
+/** Feed one SSE `data:` payload from `/v1/messages`. */
+export declare function processAnthropicStreamLine(line: string, state: KimiCodeStreamState): StreamChunk[];
+/**
+ * Rolling per-process view of how well the prefix cache is working.
+ *
+ * Kimi's cache is automatic and content-hash based, so the only way to know
+ * whether a session is actually benefiting is to watch the read ratio. It is a
+ * diagnostic: nothing here changes a request.
+ */
+export interface KimiCodeCacheStats {
+    /** Requests that reported usage. */
+    requests: number;
+    /** Prompt tokens that were served from cache. */
+    cachedTokens: number;
+    /** Prompt tokens that had to be processed fresh. */
+    freshTokens: number;
+    /** Output tokens, which reasoning is billed against. */
+    outputTokens: number;
+    /** Prompt tokens the provider counted as cache writes (always 0 on this route). */
+    cacheWriteTokens: number;
+}
+/** Record one request's usage into the rolling totals. */
+export declare function recordCacheStats(state: KimiCodeStreamState): void;
+/** Current rolling totals, plus the derived hit ratio. */
+export declare function getCacheStats(): KimiCodeCacheStats & {
+    hitRatio: number | null;
+};
+/** Test seam and an explicit reset for a new session. */
+export declare function resetCacheStats(): void;
+/** Flush every open block, then emit usage and the terminal finish. */
+export declare function closeStream(state: KimiCodeStreamState): StreamChunk[];
+/** Model families whose stream never carried a terminal event. */
+export declare function assertStreamComplete(state: KimiCodeStreamState): void;
+export {};
+//# sourceMappingURL=mapper.d.ts.map

package/lib/types/host/kimi-code/mapper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mapper.d.ts","sourceRoot":"","sources":["../../../../src/host/kimi-code/mapper.ts"],"names":[],"mappings":"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"}

package/lib/types/host/kimi-code/modalities.d.ts

@@ -0,0 +1,94 @@
+/**
+ * Kimi Code's extra request modalities, declared into DSH's provider-neutral
+ * vocabularies by this plugin alone.
+ *
+ * DSH ships ModelModalityMap = { text, image } and a ContentBlockMap with no
+ * video entry, but both are merge-extensible interfaces: a plugin may widen
+ * them with a TypeScript module augmentation. That is what this file does, so
+ * Kimi's documented video_in capability can travel through DSH's real
+ * capability pipeline - the same one that gates read_image, prompt admission,
+ * and subagent delegation - instead of being display-only trivia in a tooltip.
+ *
+ * Nothing here modifies DSH. The augmentation lives in this plugin's
+ * compilation unit; DSH's own sources keep compiling against the two
+ * modalities they already know.
+ *
+ * The block shape deliberately mirrors ImageAttachmentRef field for field.
+ * DSH itself never constructs a video block - the attachment service only
+ * promotes images - so the only readers are this plugin's request mapper and
+ * its tests.
+ */
+/**
+ * Container formats the Kimi coding endpoint accepts as video input.
+ *
+ * Transcribed from the official vision guide and file-upload reference; the
+ * service validates the media type, so an unlisted container is reported
+ * before it is base64-expanded into a request that would be rejected.
+ */
+export declare const KIMI_VIDEO_MEDIA_TYPES: readonly string[];
+/** Runtime membership test for one video container. */
+export declare function isVideoMediaType(mediaType: string): boolean;
+/**
+ * One durable video reference carried by a request.
+ *
+ * attachmentId is a plain string rather than DSH's branded AttachmentId: no
+ * DSH service issues this identifier, so branding it would imply an origin
+ * that does not exist. The field name matches ImageAttachmentRef so one
+ * traversal helper can walk both block kinds.
+ */
+export interface VideoAttachmentRef {
+    attachmentId: string;
+    /** Verified media type, for example video/mp4. */
+    mediaType: string;
+    /** Exact encoded byte length. */
+    bytes: number;
+    /** Intrinsic duration in milliseconds, when the producer knows it. */
+    durationMs?: number;
+    /** Optional display name, stripped of any local path. */
+    name?: string;
+}
+/** One video occurrence in message content. */
+export interface VideoBlock {
+    type: 'video';
+    attachment: VideoAttachmentRef;
+}
+declare module '@deepseek-ai/dsh-llm' {
+    interface ModelModalityMap {
+        /** Widened by this plugin: Kimi's k3 and kimi-for-coding accept video. */
+        video: 'video';
+    }
+    interface ContentBlockMap {
+        /** Widened by this plugin; only the Kimi Code mapper reads it. */
+        video: VideoBlock;
+    }
+}
+/** Base64 length of raw bytes, including padding. */
+export declare function base64LengthOf(bytes: number): number;
+/** Canonical data URL the OpenAI-compatible video part carries. */
+export declare function videoDataUrl(mediaType: string, base64: string): string;
+/**
+ * Human-readable byte size for a refusal message.
+ * @param bytes - exact encoded byte length.
+ */
+export declare function formatMediaBytes(bytes: number): string;
+/** Why one video occurrence was replaced by text instead of being sent. */
+export type VideoOmissionReason = 'unsupported-model' | 'unreadable' | 'unsupported-container'
+/** The selected protocol has no documented video part, so none is sent. */
+ | 'unsupported-wire';
+/**
+ * Deterministic text standing in for a video the request cannot carry.
+ *
+ * The model is told the video existed and why it is absent, so it asks for a
+ * description instead of answering as though the message were empty.
+ * @param reason - why the occurrence was omitted.
+ * @param label - display name or attachment id, when known.
+ */
+export declare function videoOmissionText(reason: VideoOmissionReason, label?: string): string;
+/** Attachment id or display name for one block, whichever is present. */
+export declare function videoBlockLabel(block: {
+    attachment?: {
+        name?: string;
+        attachmentId?: string;
+    };
+}): string | undefined;
+//# sourceMappingURL=modalities.d.ts.map

package/lib/types/host/kimi-code/modalities.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"modalities.d.ts","sourceRoot":"","sources":["../../../../src/host/kimi-code/modalities.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH;;;;;;GAMG;AACH,eAAO,MAAM,sBAAsB,EAAE,SAAS,MAAM,EAUnD,CAAA;AAED,uDAAuD;AACvD,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAE3D;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,kBAAkB;IACjC,YAAY,EAAE,MAAM,CAAA;IACpB,kDAAkD;IAClD,SAAS,EAAE,MAAM,CAAA;IACjB,iCAAiC;IACjC,KAAK,EAAE,MAAM,CAAA;IACb,sEAAsE;IACtE,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,yDAAyD;IACzD,IAAI,CAAC,EAAE,MAAM,CAAA;CACd;AAED,+CAA+C;AAC/C,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,OAAO,CAAA;IACb,UAAU,EAAE,kBAAkB,CAAA;CAC/B;AAED,OAAO,QAAQ,sBAAsB,CAAC;IACpC,UAAU,gBAAgB;QACxB,0EAA0E;QAC1E,KAAK,EAAE,OAAO,CAAA;KACf;IAED,UAAU,eAAe;QACvB,kEAAkE;QAClE,KAAK,EAAE,UAAU,CAAA;KAClB;CACF;AAED,qDAAqD;AACrD,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAEpD;AAED,mEAAmE;AACnE,wBAAgB,YAAY,CAAC,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAEtE;AACD;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAItD;AAED,2EAA2E;AAC3E,MAAM,MAAM,mBAAmB,GAC3B,mBAAmB,GACnB,YAAY,GACZ,uBAAuB;AACzB,2EAA2E;GACzE,kBAAkB,CAAA;AAEtB;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,mBAAmB,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,MAAM,CAYrF;AAED,yEAAyE;AACzE,wBAAgB,eAAe,CAAC,KAAK,EAAE;IAAE,UAAU,CAAC,EAAE;QAAE,IAAI,CAAC,EAAE,MAAM,CAAC;QAAC,YAAY,CAAC,EAAE,MAAM,CAAA;KAAE,CAAA;CAAE,GAAG,MAAM,GAAG,SAAS,CAIpH"}

package/lib/types/host/kimi-code/model-catalog.d.ts

@@ -0,0 +1,77 @@
+/**
+ * Static catalog of the models the Kimi Code subscription serves.
+ *
+ * Transcribed from the official model table at
+ * https://www.kimi.com/code/docs/en/kimi-code/models.html. Model version names
+ * (K3, K2.8 Preview) are NOT valid request ids: only the ids below may appear in
+ * a request body, or the service answers 401 "Your model id does not exist".
+ */
+import type { KimiCodeReasoningEffort } from '../../shared/kimi-code-contracts.ts';
+/** One model the Kimi Code endpoint serves to subscription accounts. */
+export interface KimiCodeCatalogModel {
+    /** Exact model id to put on the wire. */
+    id: string;
+    /** Display name shown in the picker. */
+    name: string;
+    /** Marketing version the id maps to, e.g. K3. */
+    version: string;
+    /**
+     * Context window used unless the user overrides it.
+     *
+     * For `k3` this is deliberately the Moderato-tier 256K bound rather than the
+     * 1M the model can reach: the server rejects a request that exceeds the
+     * signed-in plan's entitlement with a 401, so a session that silently grew
+     * past 256K on a Moderato account would fail hard instead of compacting.
+     * Allegretto-and-above users raise it with the context-window override.
+     */
+    contextWindow: number;
+    /** Context the highest tier unlocks, when it is larger than {@link contextWindow}. */
+    maxContextWindow: number | null;
+    /** Output cap requested when the caller omits one. */
+    maxTokens: number;
+    /** Input the model accepts; DSH only maps the text and image entries. */
+    inputModalities: readonly ('text' | 'image' | 'video')[];
+    /** Thinking levels the model accepts, in escalating order. */
+    reasoningEfforts: readonly KimiCodeReasoningEffort[];
+    /** Thinking level used when the conversation does not pick one. */
+    defaultReasoningEffort: KimiCodeReasoningEffort | null;
+    /** Subscription tier needed for the full model, when not every member has it. */
+    minimumPlan: string | null;
+    /** Subscription tier needed for the full context window, when it differs. */
+    contextPlan: string | null;
+    /** One-line description from the official table. */
+    description: string;
+    /**
+     * Whether the model accepts message-level tool declarations.
+     *
+     * Taken from the capability list the official client ships in its own managed
+     * model table, which is more specific than the wire documentation (that names
+     * K3 alone, because it describes the K3 request schema):
+     *
+     * - k3, k3-256k, kimi-for-coding -> declared;
+     * - kimi-for-coding-highspeed   -> NOT declared.
+     *
+     * The live `/v1/models` listing remains authoritative when it speaks: its own
+     * `supports_dynamic_tools` overrides this flag, including to turn it off.
+     */
+    supportsDynamicTools: boolean;
+    /** Relative quota cost of this model against the cheapest one. */
+    quotaMultiplier: number;
+    /** How fast the model emits output. */
+    speed: 'regular' | 'highspeed';
+}
+/**
+ * The four ids the subscription serves today.
+ *
+ * `kimi-for-coding` is the alias that never changes: Moonshot upgrades the model
+ * behind it in place (K2.7 Code became K2.8 Preview without a config change), so
+ * this entry is the durable default a user can leave selected.
+ */
+export declare const KIMI_CODE_MODELS: readonly KimiCodeCatalogModel[];
+/** Registry entry for one model id, or undefined when the id is unknown. */
+export declare function kimiCodeModelDef(modelId: string): KimiCodeCatalogModel | undefined;
+/** Membership test for one known model id. */
+export declare function isKimiCodeModelId(value: unknown): boolean;
+/** Display name for one model id, falling back to the raw id so nothing is hidden. */
+export declare function kimiCodeModelName(modelId: string): string;
+//# sourceMappingURL=model-catalog.d.ts.map

package/lib/types/host/kimi-code/model-catalog.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"model-catalog.d.ts","sourceRoot":"","sources":["../../../../src/host/kimi-code/model-catalog.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,qCAAqC,CAAA;AAElF,wEAAwE;AACxE,MAAM,WAAW,oBAAoB;IACnC,yCAAyC;IACzC,EAAE,EAAE,MAAM,CAAA;IACV,wCAAwC;IACxC,IAAI,EAAE,MAAM,CAAA;IACZ,iDAAiD;IACjD,OAAO,EAAE,MAAM,CAAA;IACf;;;;;;;;OAQG;IACH,aAAa,EAAE,MAAM,CAAA;IACrB,sFAAsF;IACtF,gBAAgB,EAAE,MAAM,GAAG,IAAI,CAAA;IAC/B,sDAAsD;IACtD,SAAS,EAAE,MAAM,CAAA;IACjB,yEAAyE;IACzE,eAAe,EAAE,SAAS,CAAC,MAAM,GAAG,OAAO,GAAG,OAAO,CAAC,EAAE,CAAA;IACxD,8DAA8D;IAC9D,gBAAgB,EAAE,SAAS,uBAAuB,EAAE,CAAA;IACpD,mEAAmE;IACnE,sBAAsB,EAAE,uBAAuB,GAAG,IAAI,CAAA;IACtD,iFAAiF;IACjF,WAAW,EAAE,MAAM,GAAG,IAAI,CAAA;IAC1B,6EAA6E;IAC7E,WAAW,EAAE,MAAM,GAAG,IAAI,CAAA;IAC1B,oDAAoD;IACpD,WAAW,EAAE,MAAM,CAAA;IACnB;;;;;;;;;;;;OAYG;IACH,oBAAoB,EAAE,OAAO,CAAA;IAC7B,kEAAkE;IAClE,eAAe,EAAE,MAAM,CAAA;IACvB,uCAAuC;IACvC,KAAK,EAAE,SAAS,GAAG,WAAW,CAAA;CAC/B;AAED;;;;;;GAMG;AACH,eAAO,MAAM,gBAAgB,EAAE,SAAS,oBAAoB,EAwE3D,CAAA;AAID,4EAA4E;AAC5E,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,oBAAoB,GAAG,SAAS,CAElF;AAED,8CAA8C;AAC9C,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAEzD;AAED,sFAAsF;AACtF,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAEzD"}