@huaweidevtools/aishell-dsh-llm 0.0.1-beta.2 → 0.0.2

package/lib/types/adapter.d.ts

@@ -10,13 +10,43 @@
  */
 import { LlmAdapter } from '@deepseek-ai/dsh-llm';
 import type { GenerateOptions, LlmModelInfo, LlmProviderInfo, LlmResolvedModelInfo, StreamChunk } from '@deepseek-ai/dsh-llm';
+import type { AttachmentStore } from '@deepseek-ai/dsh-attachment';
 import type { CredentialsStore } from '@huaweidevtools/aishell-dsh-credentials-store';
+import { type ImageRequestBudget } from './images.ts';
 /** Adapter construction options. */
 export interface GatewayAdapterOptions {
-    /** Chat API base URL (e.g. `https://api.aishell.openbuildlab.com`). */
-    readonly baseUrl: string;
+    /**
+     * Resolve the current chat API base URL (e.g. `https://api.aishell.openbuildlab.com/v1`).
+     *
+     * A reader, not a value, for the same reason `resolveAttachments` is: this
+     * plugin's whole Config is `Volatile`, so a settings edit is a
+     * volatile-only update. The loader commits such an update into the existing
+     * references and returns without re-running `apply()`
+     * (`cordis-plugin-loader/lib/index.js:381-388`), which means the adapter
+     * instance outlives the value it was built with. A captured string would
+     * leave the settings surface showing the new endpoint while requests kept
+     * going to the old one — silently, and for the life of the process.
+     */
+    readonly resolveBaseUrl: () => string;
     /** Credential store for reading AK/SK. */
     readonly keyring: CredentialsStore;
+    /**
+     * Resolve the mounted attachment service, when the deployment has one.
+     *
+     * Resolved per request rather than captured at construction: the service is
+     * provided by a sibling plugin whose fiber may mount after this one, and a
+     * captured `undefined` would disable image input for the whole session.
+     */
+    readonly resolveAttachments?: () => AttachmentStore | undefined;
+    /** Mounted filesystem provider, mapped into the tool execution world for image handle paths. */
+    readonly resolveHostPath?: (hostPath: string) => string | undefined;
+    /**
+     * Resolve the per-image projection policy, read per request so a budget edit
+     * takes effect without a reload — same reasoning as `resolveBaseUrl`.
+     */
+    readonly resolveImageBudget: () => ImageRequestBudget;
+    /** Resolve accumulated represented base64 bytes one request may carry before images must be offloaded. */
+    readonly resolveMaxRequestImageBytes: () => number;
 }
 export declare class GatewayAdapter extends LlmAdapter {
     private readonly opts;
@@ -34,6 +64,17 @@ export declare class GatewayAdapter extends LlmAdapter {
     private fetchWireModels;
     listModels(provider: string): Promise<readonly LlmModelInfo[]>;
     resolveModel(provider: string, model: string): Promise<LlmResolvedModelInfo>;
+    /**
+     * Whether a usable AK/SK pair is stored.
+     *
+     * The one predicate behind every "can this route do anything" question:
+     * `fetchWireModels` returns an empty catalog without it, and the Models-page
+     * card reports readiness from it. Kept in one place so the catalog and the
+     * card cannot disagree about whether this route is usable.
+     *
+     * @returns whether both halves of the signing credential are present.
+     */
+    hasCredentials(): boolean;
     /** Read AK/SK (and optional SecurityToken) from the credential store. */
     private readCredentials;
     /** Read credentials or throw MISSING_CREDENTIAL — every signing code path goes through here. */
@@ -43,6 +84,48 @@ export declare class GatewayAdapter extends LlmAdapter {
      * signing flow: read credentials → sign → attach headers → fetch.
      */
     private signedFetch;
+    /**
+     * Diagnose an "unsupported model" rejection and append what to do about it.
+     *
+     * The gateway answers a model id it does not carry with `AISHELL.1004`
+     * (`model_not_found`, HTTP 404 — see {@link isModelNotFound}). The default
+     * selection is a pinned literal (it must be readable before any credential or
+     * network call could enumerate the catalog), so the day the catalog drops
+     * that id, every fresh session fails here. Rather than leave the user to
+     * reverse-engineer the supported set, the failure itself asks the gateway
+     * (the catalog cache usually makes this a second signed GET already in
+     * flight) and names the models it currently accepts.
+     *
+     * Returns '' for any other failure, so the message stays untouched there.
+     */
+    private unsupportedModelHint;
+    /**
+     * Resolve one image occurrence's execution-world read path, when the
+     * deployment exposes one. Only enriches the handle text written beside an
+     * image; a deployment without a filesystem provider simply yields the
+     * shorter form.
+     *
+     * Deliberately unguarded, like the official adapters: this throws only for
+     * an invalid durable reference, and every reference reaching here was
+     * already validated by the `readImageRequest` that loaded its bytes — so a
+     * throw means the attachment record is inconsistent, which should surface
+     * rather than be absorbed into less informative handle text.
+     */
+    private readonly imageAccess;
+    /**
+     * Turn the harness history into the wire body, loading image bytes on the
+     * way.
+     *
+     * Deliberately the whole image pipeline and nothing else, so `stream` stays
+     * about transport. Ordering matters and mirrors the official adapters:
+     * resolve the attachment service, prepare one request version per retained
+     * image, fail the request if the budget is exceeded (handing
+     * `dsh-compaction-image-offload` its decision), and only then project the
+     * offloaded occurrences to placeholder text — a mark set by an earlier
+     * request's offload decision, which serialization must replace rather than
+     * look up bytes for.
+     */
+    private buildBody;
     stream(options: GenerateOptions): AsyncIterable<StreamChunk>;
 }
 //# sourceMappingURL=adapter.d.ts.map

package/lib/types/client/ProviderCard.d.ts

@@ -0,0 +1,77 @@
+/**
+ * The aishell row's Edit-card extension: a one-line readiness status + the
+ * live gateway model catalog.
+ *
+ * The Models page's own editor for an adapter family it does not know renders
+ * the host's fallback hint ("other fields live in cordis.patch.yml") with a
+ * disabled Apply — nothing to edit, because the aishell profile has no fields
+ * the host editor knows how to write. What the user actually needs from this
+ * card is the other direction: to READ the family's state.
+ *
+ * Scope discipline: this page answers "can I use this provider, and what does
+ * it carry" — one readiness line whose credential fact comes from
+ * `aishell-credentials`' settings namespace (managed at Settings → AI Shell;
+ * the card never names accounts or manages anything). The model catalog comes
+ * from the gateway through the Host half's `api/aishell/models` route and is
+ * likewise read-only — the gateway owns it.
+ *
+ * @module @huaweidevtools/aishell-dsh-llm/client/ProviderCard
+ */
+import { type ReactNode } from 'react';
+import type { SnapshotStore } from '@deepseek-ai/dsh-client-store';
+import type { InjectFace, PropsRuntime } from '@deepseek-ai/dsh-client-ui-slots';
+/** The route body the Host half answers (see its ModelsRouteBody). */
+interface ModelsRouteBody {
+    readonly credentialsPresent: boolean;
+    readonly models: ReadonlyArray<{
+        readonly id: string;
+        readonly inputModalities: readonly string[];
+    }>;
+}
+/**
+ * Credential presence, read from the settings namespace `aishell-credentials`
+ * owns. The card only needs the presence flag for its readiness line; the
+ * account name stays in the credentials section that owns it.
+ */
+export interface CredentialSnapshot {
+    readonly credentialsStored: boolean;
+}
+/** Full component props: the seat's owner share + the inject face. */
+export type AishellProviderCardProps = PropsRuntime<'settings.models.provider-card'> & InjectFace<AishellProviderCardInjected>;
+/** Injected hooks bound in the client half's apply(). */
+export interface AishellProviderCardInjected {
+    hooks: {
+        /** Credential presence from the aishell-client-credentials namespace. */
+        credentials: SnapshotStore<CredentialSnapshot>;
+    };
+}
+/**
+ * Render the aishell family's card extension.
+ *
+ * The parent renders this inside the host editor's card (below its fallback
+ * hint), so the visual style follows the surrounding card rather than opening
+ * a panel of its own: one readiness line and one catalog list, no buttons —
+ * the host card's Cancel stays the only control. Readiness folds the
+ * credential fact into a single conclusion (the question this page asks is
+ * "can I use this provider", not "what are my credentials"); details and
+ * management of credentials belong to the AI Shell settings section, which
+ * the unconfigured hint names.
+ */
+/**
+ * What an empty catalog means, and therefore what the card says about it.
+ *
+ * An empty model list has two unrelated causes that look identical on the
+ * wire: the gateway returned nothing, or the request was never signed because
+ * no credentials are stored. Only the second one is actionable, and it is the
+ * state every new user starts in — so it has to name the place to fix it.
+ *
+ * Extracted from the render so the branch is testable without a DOM: the
+ * repo's client-side tests cover pure logic, not components.
+ *
+ * @param catalog - the route body, or `undefined` while it is still loading.
+ * @returns the text to show, which the caller renders as-is.
+ */
+export declare function catalogStatusText(catalog: ModelsRouteBody | undefined): string;
+export declare function AishellProviderCard(props: AishellProviderCardProps): ReactNode;
+export {};
+//# sourceMappingURL=ProviderCard.d.ts.map

package/lib/types/client/index.d.ts

@@ -0,0 +1,21 @@
+/**
+ * aishell LLM browser half — fills the Models page's provider-card seat.
+ *
+ * The Models page's Edit card for an adapter family it does not know renders
+ * the host's fallback hint and nothing editable. This plugin owns the family,
+ * so it fills the card itself through the `settings.models.provider-card`
+ * seat (keyed by the `aishell-llm` settings namespace, which the Host half's
+ * directory entry names): a read-only credential line (managed by
+ * `aishell-credentials`, shown with the verified account name) and the live
+ * gateway model catalog, read from the Host half's `api/aishell/models` route
+ * — the same cache `listModels` serves, so the card and the pickers cannot
+ * disagree about what the gateway carries.
+ *
+ * @module @huaweidevtools/aishell-dsh-llm/client
+ */
+import type { Context as ClientContext } from '@deepseek-ai/cordis';
+export type { AishellProviderCard, AishellProviderCardProps } from './ProviderCard.tsx';
+/** Required services. */
+export declare const inject: string[];
+export declare function apply(ctx: ClientContext): void;
+//# sourceMappingURL=index.d.ts.map

package/lib/types/images.d.ts

@@ -0,0 +1,120 @@
+/**
+ * Request-image preparation for the aishell gateway adapter.
+ *
+ * The harness hands an adapter durable *references*, never bytes: an
+ * {@link ImageBlock} carries an opaque `attachmentId` that is explicitly
+ * "never a filesystem path or bearer URL". Turning one into the base64 payload
+ * an OpenAI `image_url` part needs is therefore an asynchronous read against
+ * the mounted attachment service — which is why this runs as a step ahead of
+ * serialization rather than inside it.
+ *
+ * Mirrors the official adapters' shape (`dsh-llm-pi-ai`'s `collectImageRefs` /
+ * `prepareRequestImages`, `dsh-llm-deepseek`'s `prepareImages`): collect the
+ * retained references, ask the attachment service for one deterministic
+ * request version each, and let the route's budget decide whether the request
+ * fits.
+ *
+ * @module @huaweidevtools/aishell-dsh-llm/images
+ */
+import type { AttachmentStore, ImageAttachmentRef, RequestImageAttachment } from '@deepseek-ai/dsh-attachment';
+import type { ImageAttachmentAccessResolver, RequestMessage } from '@deepseek-ai/dsh-llm';
+/** Key under which one durable image's request version is held. */
+export type ImageKey = ImageAttachmentRef['attachmentId'];
+/** Request versions by durable attachment id, as {@link prepareRequestImages} returns them. */
+export type RequestImages = ReadonlyMap<ImageKey, RequestImageAttachment>;
+/**
+ * The route's per-image projection policy: the total-pixel cap one image is
+ * scaled into, and the encoded-byte target the encoder aims for. Both are
+ * config fields on this plugin's Config, sharing the pi-ai defaults.
+ */
+export interface ImageRequestBudget {
+    /** Positive width-times-height cap one request image is projected into. */
+    readonly maxPixels: number;
+    /** Encoded-byte target per request image; the smallest ladder output wins when none fits. */
+    readonly maxBytes: number;
+}
+/**
+ * Execution-world path resolver, re-exported under this module's vocabulary.
+ * The official type rather than a local restatement: it is what
+ * `requestImageHandleText` / `offloadedImageText` accept, so an ad-hoc copy
+ * could drift from the contract it is passed into.
+ */
+export type ImageAccessResolver = ImageAttachmentAccessResolver;
+/**
+ * True when any message carries an image block — the guard that decides
+ * whether this adapter needs the attachment service at all.
+ *
+ * @param messages - complete request history.
+ * @returns whether any message content holds an image.
+ */
+export declare function historyHasImage(messages: readonly RequestMessage[]): boolean;
+/**
+ * Reject image blocks in roles the wire format cannot carry them in.
+ *
+ * A user or tool-result message maps onto content parts, so an image there is
+ * representable. Every other role serializes to a plain string (assistant
+ * text plus tool calls, system/developer prose), where an image would be
+ * silently dropped — the exact failure this module exists to remove, so it
+ * fails loud instead.
+ *
+ * @param messages - complete request history.
+ * @throws LlmError `UNSUPPORTED_CONTENT` naming the offending role.
+ */
+export declare function assertImageRoles(messages: readonly RequestMessage[]): void;
+/**
+ * Resolve one request version per retained image, keyed by durable attachment
+ * id so a reference shared by several occurrences is read once.
+ *
+ * Occurrences already marked `offloaded` are skipped: their bytes are not sent
+ * (serialization replaces them with placeholder text), so reading them would
+ * be work whose result nothing consumes.
+ *
+ * @param messages - complete request history.
+ * @param attachments - mounted attachment service.
+ * @param budget - projection policy for this route.
+ * @param signal - request cancellation, honoured by the attachment read.
+ * @returns request versions by durable attachment id.
+ */
+export declare function prepareRequestImages(messages: readonly RequestMessage[], attachments: AttachmentStore, budget: ImageRequestBudget, signal?: AbortSignal): Promise<RequestImages>;
+/**
+ * Request version for one retained occurrence, or a loud failure.
+ *
+ * Every image block reaching serialization must have been prepared, so a
+ * miss is a bug in this adapter rather than bad input — but the alternative
+ * (letting the lookup produce `undefined` and reading `.bytes` off it) turns
+ * it into a `TypeError` from deep inside the request body, so it is named.
+ *
+ * @param images - prepared request versions.
+ * @param ref - durable reference of one retained occurrence.
+ * @returns the request version carrying that image's bytes.
+ * @throws LlmError `INVALID_REQUEST` when the reference was never prepared.
+ */
+export declare function requireRequestImage(images: RequestImages, ref: ImageAttachmentRef): RequestImageAttachment;
+/**
+ * Replace every offloaded occurrence with its placeholder text.
+ *
+ * The durable `offloaded` mark is a surface fact shared by all routes; only
+ * the placeholder wording is route-owned. Request assembly does not do this
+ * for adapters, so an adapter that skips it would send an image whose bytes
+ * it deliberately never loaded.
+ *
+ * @param messages - complete request history.
+ * @param resolveAccess - execution-world path resolver, when one is available.
+ * @returns the history with offloaded occurrences projected to text.
+ */
+export declare function projectOffloaded(messages: readonly RequestMessage[], resolveAccess?: ImageAccessResolver): readonly RequestMessage[];
+/**
+ * Fail the request when its retained images exceed the route's byte budget.
+ *
+ * This adapter does not offload on its own: the durable decision belongs to
+ * the surface, and `dsh-compaction-image-offload` (mounted by `dsh-base`) is
+ * the component that records it and retries the step. Throwing the canonical
+ * code with the required count is what hands it that decision.
+ *
+ * @param messages - complete request history, carrying the surface's offload marks.
+ * @param images - prepared request versions.
+ * @param maxBytes - accumulated represented base64 bytes this route accepts.
+ * @throws LlmError `IMAGE_OFFLOAD_REQUIRED` carrying how many more occurrences must be offloaded.
+ */
+export declare function assertRequestImageBudget(messages: readonly RequestMessage[], images: RequestImages, maxBytes: number): void;
+//# sourceMappingURL=images.d.ts.map

package/lib/types/index.d.ts

@@ -10,20 +10,84 @@
  * Credential management (settings namespace + watch → store transfer) lives
  * in `aishell-credentials`; this plugin only consumes the stored credentials.
  *
+ * This plugin also declares the `aishell` route in the configurable-provider
+ * directory (`registerConfigurableProviders`), which is what the Models page
+ * joins with live routes — and it carries a Config schema, without which the
+ * settings mirror (and therefore the Models row) never lists this namespace.
+ *
  * @module @huaweidevtools/aishell-dsh-llm
  */
-import type { Context } from '@deepseek-ai/cordis';
+import type { Context, Volatile } from '@deepseek-ai/cordis';
+import z from '@deepseek-ai/schemastery';
+import { GatewayAdapter } from './adapter.ts';
 export type { GatewayAdapter, GatewayAdapterOptions } from './adapter.ts';
 /** Plugin config. */
 export interface Config {
     /** Chat API base URL. Default: the public aishell gateway. */
-    readonly baseUrl?: string;
-    /** Credential store service name; defaults to `'aishell-dsh'`. */
-    readonly keyringService?: string;
+    readonly baseUrl: Volatile<string>;
+    /** Credential store service name; empty selects the default `'aishell-dsh'`. */
+    readonly keyringService: Volatile<string | undefined>;
+    /** Total-pixel cap one request image is projected into. */
+    readonly requestImagePixelBudget: Volatile<number>;
+    /** Encoded-byte target for one request image. */
+    readonly requestImageMaxBytes: Volatile<number>;
+    /** Accumulated base64 image bytes one request accepts before offload is required. */
+    readonly maxRequestImageBytes: Volatile<number>;
 }
+/**
+ * Settings schema for this entry.
+ *
+ * The schema exists for two reasons beyond configurability: the settings
+ * mirror only lists namespaces whose plugin declares a Config, and the Models
+ * page derives a provider row's existence from that listing — without a
+ * schema, the `aishell` route registers its adapter but never shows up as a
+ * configurable provider.
+ */
+export declare const Config: z<Schemastery.ObjectS<NoInfer<{
+    baseUrl: z<string, string, "volatile-defined">;
+    keyringService: z<string, string, "volatile">;
+    requestImagePixelBudget: z<number, number, "volatile-defined">;
+    requestImageMaxBytes: z<number, number, "volatile-defined">;
+    maxRequestImageBytes: z<number, number, "volatile-defined">;
+}>>, Schemastery.ObjectT<NoInfer<{
+    baseUrl: z<string, string, "volatile-defined">;
+    keyringService: z<string, string, "volatile">;
+    requestImagePixelBudget: z<number, number, "volatile-defined">;
+    requestImageMaxBytes: z<number, number, "volatile-defined">;
+    maxRequestImageBytes: z<number, number, "volatile-defined">;
+}>>, "plain">;
+/**
+ * The catalog the route answers with: the gateway's `/models` entries, mapped
+ * to the display shape the browser card renders, plus the credential state
+ * that decides which of the two postures the card shows. Detached plain data —
+ * no secret rides on it, ever (presence flags only).
+ */
+export interface ModelsRouteBody {
+    /** Whether a usable AK/SK pair is stored — the fact that separates "empty catalog" from "no credentials". */
+    readonly credentialsPresent: boolean;
+    readonly models: ReadonlyArray<{
+        readonly id: string;
+        readonly inputModalities: readonly string[];
+    }>;
+}
+/**
+ * Build the route body from the adapter's own catalog cache, so the card and
+ * the pickers cannot disagree about what the gateway carries.
+ *
+ * `credentialsPresent` is read from the adapter rather than assumed: without
+ * credentials `listModels` answers `[]` for a reason that is not "the gateway
+ * has no models", and the card's empty state is the one place a fresh user
+ * learns which of the two it is.
+ *
+ * Returned as a plain function of the adapter so a test can pin the mapping
+ * without a live context; `apply` wires it to the fetch route.
+ */
+export declare function createModelsRoute(adapter: GatewayAdapter): () => Promise<Response>;
 export declare const name = "aishell-llm";
 export declare const inject: string[];
 /** The provider route this plugin owns. */
 export declare const PROVIDER = "aishell";
-export declare function apply(ctx: Context, config?: Config): void;
+/** Human-readable provider name the Models page and pickers show. */
+export declare const PROVIDER_DISPLAY_NAME = "AI Shell (Huawei Cloud)";
+export declare function apply(ctx: Context, config: Config): void;
 //# sourceMappingURL=index.d.ts.map

package/lib/types/serialize.d.ts

@@ -1,13 +1,30 @@
 /**
  * Serialize harness {@link GenerateOptions} into an OpenAI-compatible wire request.
  *
- * Text-only: image blocks are not mapped (the gateway adapter is for text
- * models; image support can be added later by extending `blocksToText`).
+ * Messages without images serialize to a plain string, exactly as before image
+ * support existed. A message carrying an image serializes to an ordered part
+ * list instead — a handle-text part naming the image, then the image itself as
+ * a base64 data URL — which is the only shape an OpenAI-compatible endpoint
+ * accepts image input in.
+ *
+ * Image bytes are not read here. The harness hands over durable references,
+ * not bytes, so `prepareRequestImages` resolves them one step ahead of this
+ * call and passes the result in; that keeps this function synchronous and
+ * keeps the one await in the adapter, where the attachment service is
+ * reachable.
  *
  * @module @huaweidevtools/aishell-dsh-llm/serialize
  */
 import type { GenerateOptions } from '@deepseek-ai/dsh-llm';
+import { type ImageAccessResolver, type RequestImages } from './images.ts';
 import type { WireRequest } from './types.ts';
-/** Build the POST body for `/chat/completions`. */
-export declare function serializeRequest(options: GenerateOptions): WireRequest;
+/**
+ * Build the POST body for `/chat/completions`.
+ *
+ * @param options - provider-neutral request.
+ * @param images - prepared request versions, required only when the history carries a retained image.
+ * @param resolveAccess - execution-world path resolver for image handle text, when a provider exposes one.
+ * @returns the OpenAI-compatible request body.
+ */
+export declare function serializeRequest(options: GenerateOptions, images?: RequestImages, resolveAccess?: ImageAccessResolver): WireRequest;
 //# sourceMappingURL=serialize.d.ts.map

package/lib/types/types.d.ts

@@ -1,5 +1,5 @@
 /**
- * OpenAI-compatible chat-completions wire format (text-only).
+ * OpenAI-compatible chat-completions wire format.
  *
  * @module @huaweidevtools/aishell-dsh-llm/types
  */
@@ -16,6 +16,25 @@ export interface WireRequest {
     max_tokens?: number;
     stop?: string[];
 }
+/** One message's content: plain text, or an ordered part list when it carries an image. */
+export type WireContent = string | WireContentPart[];
+/**
+ * One content part. Only the two shapes this adapter emits are declared: text,
+ * and the base64 data URL an OpenAI-compatible endpoint reads an image from.
+ * The harness's `reasoning` blocks fold into text; `file` blocks are projected
+ * to handle text by request assembly before any adapter sees them.
+ */
+export type WireContentPart = WireTextPart | WireImageUrlPart;
+export interface WireTextPart {
+    type: 'text';
+    text: string;
+}
+export interface WireImageUrlPart {
+    type: 'image_url';
+    image_url: {
+        url: string;
+    };
+}
 /** One wire message. */
 export type WireMessage = WireSystemMessage | WireUserMessage | WireAssistantMessage | WireToolMessage;
 export interface WireSystemMessage {
@@ -24,7 +43,7 @@ export interface WireSystemMessage {
 }
 export interface WireUserMessage {
     role: 'user';
-    content: string;
+    content: WireContent;
 }
 export interface WireAssistantMessage {
     role: 'assistant';
@@ -34,6 +53,13 @@ export interface WireAssistantMessage {
 export interface WireToolMessage {
     role: 'tool';
     tool_call_id: string;
+    /**
+     * Always a string, even when the tool result carried an image. OpenAI's
+     * tool message takes text only; an image from a tool result is hoisted into
+     * a separate `user` turn instead, which is what the one OpenAI-path
+     * serializer in the ecosystem does. Widening this field would produce a
+     * request that some gateways reject with 400 and others silently drop.
+     */
     content: string;
 }
 export interface WireAssistantToolCall {
@@ -63,22 +89,19 @@ export interface WireModel {
     object?: string;
     owned_by?: string;
     created?: number;
-    capabilities?: WireModelCapabilities;
+    /**
+     * The gateway's request-modality list (`["text","image"]`) — the catalog's
+     * own answer to "what does this model accept", and the only field this
+     * adapter reads for capability. A sibling `capabilities` object is not
+     * declared: the gateway may send one, and its `image: boolean` reads like a
+     * fallback for an absent `modalities`, but nothing here consumes it, so
+     * declaring it would only suggest a fallback that does not exist.
+     */
     modalities?: string[];
     reasoning_effort?: string[];
     limits?: WireModelLimits;
     pricing?: WireModelPricing;
 }
-export interface WireModelCapabilities {
-    text?: boolean;
-    image?: boolean;
-    video?: boolean;
-    audio?: boolean;
-    streaming?: boolean;
-    thinking?: boolean;
-    tool_call?: boolean;
-    embedding?: boolean;
-}
 export interface WireModelLimits {
     context_window?: number;
     max_prompt_tokens?: number;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@huaweidevtools/aishell-dsh-llm",
   "description": "aishell LLM gateway adapter for DSH — OpenAI-compatible, Huawei Cloud AK/SK auth via credential store",
-  "version": "0.0.1-beta.2",
+  "version": "0.0.2",
   "publishConfig": {
     "access": "public"
   },
@@ -17,29 +17,58 @@
     ".": {
       "types": "./lib/types/index.d.ts",
       "default": "./lib/index.js"
-    }
+    },
+    "./client": {
+      "types": "./lib/types/client/index.d.ts",
+      "default": "./lib/client.js"
+    },
+    "./package.json": "./package.json"
   },
   "files": [
     "lib/index.js",
+    "lib/client.js",
     "lib/types/**/*.d.ts",
     "cordis.patch.yml"
   ],
   "license": "Apache-2.0",
   "dependencies": {
     "eventsource-parser": "^3.0.0",
-    "@huaweidevtools/aishell-dsh-credentials-store": "0.0.1-beta.2"
+    "@huaweidevtools/aishell-dsh-credentials-store": "0.0.2"
   },
   "peerDependencies": {
     "@deepseek-ai/cordis": "^4.0.4",
+    "@deepseek-ai/dsh-attachment": ">=0.2.0-0 <0.3.0-0",
     "@deepseek-ai/dsh-brand": ">=0.2.0-0 <0.3.0-0",
+    "@deepseek-ai/dsh-client-connection": ">=0.2.0-0 <0.3.0-0",
+    "@deepseek-ai/dsh-fs": ">=0.2.0-0 <0.3.0-0",
     "@deepseek-ai/dsh-llm": ">=0.2.0-0 <0.3.0-0"
   },
   "devDependencies": {
     "@deepseek-ai/cordis": "^4.0.4",
+    "@deepseek-ai/cordis-plugin-loader": "^1.0.5",
+    "@deepseek-ai/dsh-attachment": "0.2.0-rc.1",
     "@deepseek-ai/dsh-brand": ">=0.2.0-0 <0.3.0-0",
-    "@deepseek-ai/dsh-llm": ">=0.2.0-0 <0.3.0-0"
+    "@deepseek-ai/dsh-client-connection": "0.2.0-rc.1",
+    "@deepseek-ai/dsh-client-store": "0.2.0-rc.1",
+    "@deepseek-ai/dsh-client-ui-renderer": "0.2.0-rc.1",
+    "@deepseek-ai/dsh-client-ui-settings": "0.2.0-rc.1",
+    "@deepseek-ai/dsh-client-ui-settings-models": "0.2.0-rc.1",
+    "@deepseek-ai/dsh-client-ui-slots": "0.2.0-rc.1",
+    "@deepseek-ai/dsh-fs": "0.2.0-rc.1",
+    "@deepseek-ai/dsh-llm": ">=0.2.0-0 <0.3.0-0",
+    "@deepseek-ai/schemastery": "3.18.4",
+    "@types/react": "~18.3.1",
+    "react": "^18.2.0"
   },
   "dsh": {
+    "client": {
+      "inject": [
+        "@deepseek-ai/dsh-client-ui-settings",
+        "@deepseek-ai/dsh-client-ui-settings-models",
+        "@deepseek-ai/dsh-api-remotes"
+      ],
+      "platform": "web"
+    },
     "bundle": {
       "patch": "./cordis.patch.yml"
     }