@artenx/dshb 0.1.2 → 0.1.4

package/lib/core/workspace-instruction-context.d.ts

@@ -0,0 +1,1667 @@
+import { SessionInstructionSnapshot, SessionInstructionSnapshotStore, WorkspaceInstructionStore } from "./workspace-instructions.js";
+import { Context, Service } from "@deepseek-ai/cordis";
+import { FileAttachmentRef, ImageAttachmentRef } from "@deepseek-ai/dsh-attachment";
+//#region ../../node_modules/@deepseek-ai/dsh-typert-protocol/lib/types/types.d.ts
+declare const LOOKUP_HOST: unique symbol;
+declare const LOOKUP_WIRE: unique symbol;
+declare const CONTEXT_WIRE: unique symbol;
+/** Type-level association between a Host object and its wire identity. */
+interface TypertLookup<Host, Wire> {
+  readonly [LOOKUP_HOST]: Host;
+  readonly [LOOKUP_WIRE]: Wire;
+}
+/** Extract the Host object associated with one lookup declaration. */
+type TypertLookupHost<Lookup> = Lookup extends TypertLookup<infer Host, infer _Wire> ? Host : never;
+/** Extract the wire identity associated with one lookup declaration. */
+type TypertLookupWire<Lookup> = Lookup extends TypertLookup<infer _Host, infer Wire> ? Wire : never;
+/** Type-level association between a scoped Context kind and its wire identity. */
+interface TypertContext<Wire> {
+  readonly [CONTEXT_WIRE]: Wire;
+}
+/** Extract the wire identity associated with one scoped Context declaration. */
+type TypertContextWire<ContextType> = ContextType extends TypertContext<infer Wire> ? Wire : never;
+/** Merge-extensible Host object lookup declarations. */
+interface TypertLookupMap {}
+/** Merge-extensible scoped Context declarations. */
+interface TypertContextMap {}
+/** Awaitable disposer returned by Cordis-owned Typert registrations. */
+type TypertDisposer = () => Promise<void>;
+type StringKeyOf<Value> = Extract<keyof Value, string>;
+/** Minimal runtime-schema capability carried by strict generated codecs. */
+interface TypertSchema<Output = unknown> {
+  /**
+   * Parse and validate one boundary value.
+   * @param value - untrusted boundary value.
+   * @returns the validated value.
+   */
+  parse(value: unknown): Output;
+}
+/** Codec attached to one invocation parameter or result. */
+type TypertCodec = {
+  readonly mode: 'strict';
+  readonly typeSymbol: string;
+  readonly schema: TypertSchema;
+} | {
+  readonly mode: 'src-json';
+};
+/** One ordered business parameter in a Remote invocation. */
+interface InvocationParameterDescriptor {
+  /** Source-level parameter name. */
+  readonly name: string;
+  /** Required key in the wire `args` object. */
+  readonly wire: string;
+  /** Whether the value is JSON or requires a registered Host lookup. */
+  readonly source: 'json' | 'lookup';
+  /** Lookup key when `source` is `lookup`. */
+  readonly lookup?: string;
+  /** Boundary codec for the wire representation. */
+  readonly codec: TypertCodec;
+  /** Missing wire fields decode to `undefined` only for an explicitly declared `T | undefined`. */
+  readonly acceptsUndefined?: true;
+}
+/** Source position retained for diagnostics from generated definitions. */
+interface InvocationSourceLocation {
+  readonly file: string;
+  readonly line: number;
+  readonly column: number;
+}
+/** Carrier-independent description of one exported method invocation. */
+interface InvocationDescriptor {
+  /** Globally stable generated identity. */
+  readonly id: string;
+  /** Cordis service key owning the method. */
+  readonly service: string;
+  /** Wire namespace, defaulting to the service key. */
+  readonly namespace: string;
+  /** Public instance method name. */
+  readonly method: string;
+  /** Service member invoked when the exported method name is an alias. */
+  readonly implementation?: string;
+  /** Absent for unary calls; stream calls validate and deliver every yielded item. */
+  readonly mode?: 'stream';
+  /** Receiver selection mode. */
+  readonly invocation: {
+    readonly kind: 'direct';
+  } | {
+    readonly kind: 'context';
+    readonly context: string;
+    readonly wire: string;
+    readonly codec: TypertCodec;
+  };
+  /** Optional consuming-Context projection for one direct lookup parameter. */
+  readonly scope?: {
+    /** Context kind whose Client adapter supplies the identity. */
+    readonly context: string;
+    /** Lookup parameter wire field replaced by the Context identity. */
+    readonly wire: string;
+  };
+  /** Ordered business parameters. */
+  readonly parameters: readonly InvocationParameterDescriptor[];
+  /** Transport cancellation injected after business parameters instead of entering wire args. */
+  readonly cancellation?: {
+    /** Reserved final Host method parameter. */
+    readonly parameter: 'signal';
+  };
+  /** Codec for the unary result or each yielded stream item. */
+  readonly result: TypertCodec;
+  /** Source declaration used only for diagnostics. */
+  readonly sourceLocation?: InvocationSourceLocation;
+}
+/** Generated Host contract selected explicitly by a Client assembly. */
+interface TypertRemoteContribution {
+  /** npm package that owns the Remote methods. */
+  readonly package: string;
+  /** Consumer-side invocation descriptors generated from that package. */
+  readonly descriptors: readonly InvocationDescriptor[];
+}
+/**
+ * Resolve one validated wire identity, synchronously or asynchronously.
+ * @param id - validated wire identity.
+ * @returns the Host object, or `undefined` when unavailable.
+ */
+type TypertLookupResolver<Host = unknown, Wire = unknown> = (id: Wire) => Host | undefined | Promise<Host | undefined>;
+/** Runtime provider for one declared Host object lookup. */
+interface TypertLookupProvider<Host = unknown, Wire = unknown> {
+  /** Source parameter name recognized by the SRC weak parser. */
+  readonly parameter: string;
+  /** Wire field replacing the Host object parameter. */
+  readonly wire: string;
+  /** Canonical Host type symbol used by strict generation. */
+  readonly hostTypeSymbol: string;
+  /** Canonical wire type symbol used by strict generation. */
+  readonly wireTypeSymbol: string;
+  /**
+   * Resolve a wire identity through the provider's default policy.
+   * @param id - validated wire identity.
+   * @returns the object, `undefined` when unavailable, or either asynchronously.
+   */
+  resolve(id: Wire): Host | undefined | Promise<Host | undefined>;
+}
+/** Stable wire declaration retained after a lookup provider unloads. */
+interface TypertLookupDefinition {
+  /** Merge-declared lookup key. */
+  readonly key: string;
+  /** Source parameter name recognized by the SRC weak parser. */
+  readonly parameter: string;
+  /** Wire field replacing the Host object parameter. */
+  readonly wire: string;
+  /** Canonical Host type symbol used by strict generation. */
+  readonly hostTypeSymbol: string;
+  /** Canonical wire type symbol used by strict generation. */
+  readonly wireTypeSymbol: string;
+}
+/** Host wire-to-Context resolver plus the declaration used by strict Remote methods. */
+interface TypertHostContextAdapter<Wire = unknown> {
+  /** Wire field carrying the Context identity. */
+  readonly wire: string;
+  /** Canonical wire type symbol used by strict generation. */
+  readonly wireTypeSymbol: string;
+  /**
+   * Resolve a validated wire identity to a live Host Context.
+   * @param id - validated wire identity.
+   * @returns the Context, or `undefined` when it is unavailable.
+   */
+  resolve(id: Wire): Context | undefined | Promise<Context | undefined>;
+}
+/** Composition-owned resolver replacing one Host Context adapter's default lookup policy. */
+type TypertHostContextResolver<Wire = unknown> = (id: Wire) => Context | undefined | Promise<Context | undefined>;
+/** Client-side bidirectional Context adapter. */
+interface TypertClientContextAdapter<Wire = unknown> {
+  /**
+   * Read the identity represented by a live Client Context.
+   * @param ctx - Client Context inspected by a scoped Remote caller.
+   * @returns the wire identity, or `undefined` for another Context kind.
+   */
+  identity(ctx: Context): Wire | undefined;
+  /**
+   * Resolve a wire identity from the Client's currently materialized Contexts.
+   * @param id - validated wire identity.
+   * @returns the Client Context, or `undefined` when unavailable.
+   */
+  resolve(id: Wire): Context | undefined;
+}
+/** Notification emitted after a Typert runtime registry changes. */
+interface TypertRegistryChange {
+  readonly kind: 'local' | 'remote' | 'lookup' | 'host-context' | 'client-context';
+  readonly key: string;
+}
+/** Listener for one Typert runtime registry. */
+type TypertRegistryListener = (change: TypertRegistryChange) => void;
+/** Current-environment invocation definitions. */
+interface TypertLocalRegistry {
+  /**
+   * Look up one invocation by `<namespace>/<method>`.
+   * @param endpoint - canonical endpoint.
+   * @returns the live descriptor, or `undefined` when absent.
+   */
+  get(endpoint: string): InvocationDescriptor | undefined;
+  /**
+   * Report whether a strict definition has existed during this Typert Service lifetime.
+   * @param endpoint - canonical endpoint.
+   * @returns `true` after the endpoint has been registered at least once, even if withdrawn.
+   */
+  hasSeen(endpoint: string): boolean;
+  /** @returns a registration-order snapshot of local descriptors. */
+  list(): readonly InvocationDescriptor[];
+  /**
+   * Observe later local-definition changes.
+   * @param listener - synchronous contained observer.
+   * @returns disposer for this subscription.
+   */
+  subscribe(listener: TypertRegistryListener): TypertDisposer;
+}
+/** Consumer-selected Remote contribution registry. */
+interface TypertRemoteRegistry {
+  /**
+   * Register one generated contribution for the calling Cordis fiber.
+   * @param contribution - generated Remote descriptors.
+   * @returns disposer withdrawing the exact contribution.
+   */
+  register(contribution: TypertRemoteContribution): TypertDisposer;
+  /**
+   * Look up one Remote descriptor by endpoint.
+   * @param endpoint - canonical endpoint.
+   * @returns the descriptor, or `undefined` when unmounted.
+   */
+  get(endpoint: string): InvocationDescriptor | undefined;
+  /** @returns a registration-order snapshot of Remote descriptors. */
+  list(): readonly InvocationDescriptor[];
+  /**
+   * Observe later Remote contribution changes.
+   * @param listener - synchronous contained observer.
+   * @returns disposer for this subscription.
+   */
+  subscribe(listener: TypertRegistryListener): TypertDisposer;
+}
+/** Runtime registry for Host object lookup providers. */
+interface TypertLookupRegistry {
+  /**
+   * Register one provider under its merge-declared key.
+   * @param key - lookup key.
+   * @param provider - owning package's live resolver.
+   * @returns disposer withdrawing the exact provider.
+   */
+  register<K extends StringKeyOf<TypertLookupMap>>(key: K, provider: TypertLookupProvider<TypertLookupHost<TypertLookupMap[K]>, TypertLookupWire<TypertLookupMap[K]>>): TypertDisposer;
+  /**
+   * Replace one provider's default resolution policy while this contribution is active.
+   * Configuration may precede provider registration; without a live provider, `get()` remains unavailable.
+   * @param key - lookup key whose wire declaration remains provider-owned.
+   * @param resolver - composition-owned resolver used by every lookup of this key.
+   * @returns disposer restoring the provider's default resolver.
+   */
+  configure<K extends StringKeyOf<TypertLookupMap>>(key: K, resolver: TypertLookupResolver<TypertLookupHost<TypertLookupMap[K]>, TypertLookupWire<TypertLookupMap[K]>>): TypertDisposer;
+  /**
+   * Look up one provider by runtime key.
+   * @param key - descriptor lookup key.
+   * @returns the live provider, or `undefined` when absent.
+   */
+  get(key: string): TypertLookupProvider | undefined;
+  /** @returns lookup declarations observed during this Typert Service lifetime. */
+  definitions(): readonly TypertLookupDefinition[];
+  /** @returns a snapshot of registered provider keys. */
+  keys(): readonly string[];
+  /**
+   * Observe later lookup changes.
+   * @param listener - synchronous contained observer.
+   * @returns disposer for this subscription.
+   */
+  subscribe(listener: TypertRegistryListener): TypertDisposer;
+}
+/** Runtime registry for the Host and Client adapters of each Context kind. */
+interface TypertContextRegistry {
+  /**
+   * Register a Host Context adapter.
+   * @param key - merge-declared Context key.
+   * @param adapter - owning package's Host resolver and wire declaration.
+   * @returns disposer withdrawing the exact adapter.
+   */
+  registerHost<K extends StringKeyOf<TypertContextMap>>(key: K, adapter: TypertHostContextAdapter<TypertContextWire<TypertContextMap[K]>>): TypertDisposer;
+  /**
+   * Override one Host Context key's resolution policy for the calling fiber.
+   * Configuration may precede provider registration and restores the provider's default resolver on disposal.
+   * @param key - merge-declared Context key.
+   * @param resolver - composition-owned resolver used by every Host Context lookup of this key.
+   * @returns disposer restoring the provider's default resolver.
+   */
+  configureHost<K extends StringKeyOf<TypertContextMap>>(key: K, resolver: TypertHostContextResolver<TypertContextWire<TypertContextMap[K]>>): TypertDisposer;
+  /**
+   * Register a Client Context adapter.
+   * @param key - merge-declared Context key.
+   * @param adapter - owning package's bidirectional Client projection.
+   * @returns disposer withdrawing the exact adapter.
+   */
+  registerClient<K extends StringKeyOf<TypertContextMap>>(key: K, adapter: TypertClientContextAdapter<TypertContextWire<TypertContextMap[K]>>): TypertDisposer;
+  /**
+   * Look up a Host Context adapter.
+   * @param key - descriptor Context key.
+   * @returns the adapter, or `undefined` when absent.
+   */
+  getHost(key: string): TypertHostContextAdapter | undefined;
+  /**
+   * Look up a Client Context adapter.
+   * @param key - descriptor Context key.
+   * @returns the adapter, or `undefined` when absent.
+   */
+  getClient(key: string): TypertClientContextAdapter | undefined;
+  /**
+   * Observe later Context adapter changes.
+   * @param listener - synchronous contained observer.
+   * @returns disposer for this subscription.
+   */
+  subscribe(listener: TypertRegistryListener): TypertDisposer;
+}
+/** Minimal Typert runtime consumed through dependency inversion. */
+interface TypertRegistryContract {
+  readonly local: TypertLocalRegistry;
+  readonly remotes: TypertRemoteRegistry;
+  readonly lookups: TypertLookupRegistry;
+  readonly contexts: TypertContextRegistry;
+}
+declare module '@deepseek-ai/cordis' {
+  interface Context {
+    typert: TypertRegistryContract;
+  }
+}
+//#endregion
+//#region ../../node_modules/@deepseek-ai/dsh-typert-protocol/lib/types/index.d.ts
+/** Options for an explicit Service-to-Gateway binding. */
+interface TypertGatewayBindingOptions {
+  /** Wire namespace; defaults to the Cordis service key. */
+  readonly namespace?: string;
+}
+/** Visible declaration that one Service participates in Typert Gateway export. */
+interface TypertGatewayBinding<Service extends object = object> {
+  readonly service: Service;
+  readonly serviceKey: string;
+  readonly namespace: string;
+}
+/** Cordis Service base that exposes its registered name through Typert Gateway. */
+declare abstract class TypertRemoteService<out T = never> extends Service<T> {
+  /** Visible binding consumed by the Gateway's source-mode discovery. */
+  readonly typertRemote: TypertGatewayBinding<this>;
+  /**
+   * Register the Service and bind the same key to Typert Gateway.
+   * @param ctx - owning Cordis Context.
+   * @param serviceKey - exact Cordis service key and default wire namespace.
+   * @param options - optional distinct wire namespace.
+   */
+  protected constructor(ctx: Context, serviceKey: string, options?: TypertGatewayBindingOptions);
+}
+//#endregion
+//#region ../../node_modules/@deepseek-ai/dsh-brand/lib/types/index.d.ts
+/**
+ * Duplicate-install-safe nominal primitive helpers.
+ *
+ * A brand makes structurally identical strings or numbers non-interchangeable
+ * at the type level: a `SessionId` cannot be passed where a `ToolCallId` is
+ * expected, and an event sequence cannot be passed as a log offset. Comparison,
+ * logging, and serialization retain the underlying primitive behavior.
+ *
+ * This package owns no concrete domain value and keeps no runtime identity or mutable
+ * state, so independently installed copies produce interchangeable values.
+ *
+ * @module @deepseek-ai/dsh-brand
+ */
+declare const BRAND: unique symbol;
+/** A string carrying a compile-time-only brand `B`. */
+type Branded<B extends string> = string & {
+  readonly [BRAND]: B;
+};
+//#endregion
+//#region ../../node_modules/@deepseek-ai/dsh-llm/lib/types/brand.d.ts
+/** Stable identity carried by one message across inbox, log, and model-request boundaries. */
+type MessageId = Branded<'MessageId'>;
+/**
+ * Brand a message identifier.
+ * @param id - the opaque message identifier.
+ * @returns the same string with the message-id brand.
+ */
+declare function MessageId(id: string): MessageId;
+/**
+ * Correlates a model-issued tool call with its result. Provider-issued for
+ * real adapters; synthesized by mocks/assembler fallbacks.
+ */
+type ToolCallId = Branded<'ToolCallId'>;
+/**
+ * Brand a string as a {@link ToolCallId}.
+ * @param id - the provider-issued or synthesized call id.
+ * @returns the same string with the tool-call-id brand.
+ */
+declare function ToolCallId(id: string): ToolCallId;
+/** Provider-issued request identifier retained for diagnostics across package boundaries. */
+type ProviderRequestId = Branded<'ProviderRequestId'>;
+/**
+ * Brand a provider-issued request identifier.
+ * @param id - the opaque provider-issued string.
+ * @returns the same string, branded; no validation is performed.
+ */
+declare function ProviderRequestId(id: string): ProviderRequestId;
+/** Adapter-owned identifier for one model's selectable reasoning effort. */
+type ReasoningEffortId = Branded<'ReasoningEffortId'>;
+/**
+ * Brand an adapter-owned reasoning-effort identifier.
+ * @param id - the opaque identifier exposed by one model capability.
+ * @returns the same string, branded; no validation is performed.
+ */
+declare function ReasoningEffortId(id: string): ReasoningEffortId;
+//#endregion
+//#region ../../node_modules/@deepseek-ai/dsh-llm/lib/types/message.d.ts
+/** Provider/model identity and adapter-private replay data for an assistant message. */
+interface AssistantProvenance {
+  /** Provider route that produced the message. */
+  provider: string;
+  /** Provider model id that produced the message. */
+  model: string;
+  /**
+   * Lossless-JSON adapter state needed to replay the provider response.
+   * `LlmRuntime` exposes it to a target adapter only when that adapter instance
+   * currently owns both this historical provider and the target provider.
+   */
+  replayState?: unknown;
+}
+/** Required source of an assistant message produced by a routed model. */
+interface ModelMessageSource extends AssistantProvenance {
+  kind: 'model';
+}
+/** Required source of a user-role message carrying one tool result. */
+interface ToolMessageSource {
+  kind: 'tool';
+  callId: ToolCallId;
+}
+/** One named contribution to a `snapshot`-form context, in assembly order. */
+interface ContextSnapshotSection {
+  /** The contributing subsystem's name. */
+  readonly name: string;
+  /** That contribution's model-facing text, exactly as assembled. */
+  readonly text: string;
+}
+/**
+ * Producer-declared {@link ContextForm} and the fields that form requires,
+ * mixed into the source types that carry one.
+ *
+ * Discriminated by `form` so a producer cannot select a form without the
+ * fields needed to present it: a `notice` must record its one-line
+ * account, a `snapshot` its sections. Omitting `form` stays valid — an
+ * undeclared context is the documented default.
+ */
+type ContextFormed = {
+  readonly form?: never;
+} | {
+  readonly form: 'instructions';
+} | {
+  readonly form: 'catalog';
+} | {
+  readonly form: 'snapshot';
+  /** The named contributions this snapshot assembled, in order. */
+  readonly sections: readonly ContextSnapshotSection[];
+} | {
+  readonly form: 'notice';
+  /** One-line account of what happened, shown without expanding the row. */
+  readonly summary: string;
+} | {
+  readonly form: 'relay';
+} | {
+  readonly form: 'recall';
+};
+/**
+ * Where a message (or injected content) came from.
+ * Merge-extensible sum type — plugins add their own `kind`s.
+ */
+interface MessageSourceMap {
+  user: {
+    kind: 'user';
+  };
+  plugin: {
+    kind: 'plugin';
+    plugin: string;
+  } & ContextFormed;
+  model: ModelMessageSource;
+  tool: ToolMessageSource;
+}
+/** Any known message source, derived from {@link MessageSourceMap}; switch on `kind` and fall through unknowns (merge-extensible). */
+type MessageSource = MessageSourceMap[keyof MessageSourceMap];
+/** One immutable message representation shared by delivery, durable history, and model requests. */
+interface Message {
+  /** Stable identity preserved across every representation boundary. */
+  readonly id: MessageId;
+  /** Provider-neutral conversation role. */
+  readonly role: 'system' | 'user' | 'assistant';
+  /** Exact model-facing blocks. */
+  readonly content: ContentBlock[];
+  /** Required source fields supplied by the producer. */
+  readonly source: MessageSource;
+}
+/** A user-role specialization of the one shared message representation. */
+interface UserMessage extends Message {
+  readonly role: 'user';
+}
+type NewUserMessage = Omit<UserMessage, 'id' | 'role'>;
+/**
+ * Create one identified user-role message and freeze it before publication.
+ * @param input - complete content and source for a new user message.
+ * @returns an immutable user message with a fresh stable identity.
+ */
+declare function createUserMessage<T extends NewUserMessage>(input: T & {
+  readonly id?: never;
+  readonly role?: never;
+}): T & Pick<UserMessage, 'id' | 'role'>;
+//#endregion
+//#region ../../node_modules/@deepseek-ai/dsh-llm/lib/types/types.d.ts
+declare module '@deepseek-ai/cordis' {
+  interface Events {
+    /**
+     * The provider topology changed: an adapter registered or unregistered
+     * routes, or the configurable-provider directory gained or lost entries.
+     * This payload-free registry notification fires at each commit point
+     * (including registration disposal); consumers re-read `listProviders()`,
+     * `listModels()`, or `listConfigurableProviders()` for the new state.
+     * Observer failures are contained and cannot veto the registry mutation.
+     * @mode emit
+     */
+    'llm/adapters-updated'(): void;
+  }
+}
+/** Serializable provider or transport failure facts; policy decides whether they are retryable. */
+interface LlmFailure {
+  /** Human-readable provider or transport failure. */
+  readonly message: string;
+  /** Stable provider-neutral machine-routing code. */
+  readonly code: string;
+  /** HTTP status returned by the provider, when available. */
+  readonly status?: number;
+  /** Provider-requested delay in milliseconds, when valid and available. */
+  readonly providerRetryAfterMs?: number;
+  /** Opaque provider-issued request identifier for diagnostics. */
+  readonly requestId?: ProviderRequestId;
+}
+/** Plain text visible to the end user. */
+interface TextBlock {
+  type: 'text';
+  text: string;
+}
+/** Reasoning / thinking content, distinct from visible text. */
+interface ReasoningBlock {
+  type: 'reasoning';
+  text: string;
+}
+/**
+ * A durable raster image reference, valid in user or assistant content. The
+ * block is deliberately role-neutral; assistant-side rendering is forward
+ * compatibility — the current production adapters declare text-only output,
+ * so only user messages may carry images.
+ */
+interface ImageBlock {
+  type: 'image';
+  /** Immutable bytes and intrinsic display metadata owned by the attachment service. */
+  attachment: ImageAttachmentRef;
+}
+/**
+ * A durable verbatim file reference, valid in user content. Files never reach
+ * a provider natively: request assembly projects every occurrence to
+ * deterministic handle text (name, byte size, and the read-only saved path),
+ * so adapters and providers see text in its place while the durable log keeps
+ * the structured reference for presentation and authorization.
+ */
+interface FileBlock {
+  type: 'file';
+  /** Immutable verbatim bytes and display metadata owned by the attachment service. */
+  attachment: FileAttachmentRef;
+}
+/** A tool invocation requested by the model. */
+interface ToolCallBlock {
+  type: 'tool-call';
+  /** Provider-issued call id; correlates with the matching tool result. */
+  id: ToolCallId;
+  name: string;
+  /** Raw JSON string as produced by the model. */
+  arguments: string;
+}
+/** The result of a tool invocation, sent back to the model. */
+interface ToolResultBlock {
+  type: 'tool-result';
+  toolCallId: ToolCallId;
+  content: ContentBlock[];
+  isError?: boolean;
+}
+/**
+ * Merge-extensible content blocks keyed by `type`. New core blocks must land
+ * with adapter, UI, and compaction support.
+ */
+interface ContentBlockMap {
+  'text': TextBlock;
+  'reasoning': ReasoningBlock;
+  'image': ImageBlock;
+  'file': FileBlock;
+  'tool-call': ToolCallBlock;
+  'tool-result': ToolResultBlock;
+}
+/** The block `type` tag vocabulary; widens as plugins add entries to {@link ContentBlockMap}. */
+type ContentBlockType = keyof ContentBlockMap;
+/** Any known content block, derived from {@link ContentBlockMap}; switch on `type` and fall through unknowns (merge-extensible). */
+type ContentBlock = ContentBlockMap[ContentBlockType];
+/**
+ * Why a model response stopped.
+ * Merge-extensible so adapters can surface provider-specific reasons.
+ */
+interface FinishReasonMap {
+  'stop': {
+    kind: 'stop';
+  };
+  'tool-calls': {
+    kind: 'tool-calls';
+  };
+  'max-tokens': {
+    kind: 'max-tokens';
+  };
+  'aborted': {
+    kind: 'aborted';
+    failure: LlmFailure;
+  };
+  'error': {
+    kind: 'error';
+    failure: LlmFailure;
+  };
+}
+/** Any known finish reason, derived from {@link FinishReasonMap}; switch on `kind` and fall through unknowns (merge-extensible). */
+type FinishReason = FinishReasonMap[keyof FinishReasonMap];
+/**
+ * Token accounting for one model call (cache fields are optional).
+ *
+ * Counts are DISJOINT: `inputTokens` is uncached input only; cached input is
+ * reported separately as `cacheReadTokens`/`cacheWriteTokens` (billed input =
+ * sum of the three). Adapters whose providers fold cache hits into a total
+ * prompt count (DeepSeek's `prompt_tokens`) subtract them out.
+ */
+interface TokenUsage {
+  inputTokens: number;
+  outputTokens: number;
+  /**
+   * Exact full-call total including aggregate prompt and output tokens.
+   *
+   * Adapters preserve a provider total or derive it from authoritative
+   * aggregate prompt/output counters; they omit it when unavailable or
+   * inconsistent.
+   */
+  totalTokens?: number;
+  cacheReadTokens?: number;
+  cacheWriteTokens?: number;
+  reasoningTokens?: number;
+}
+/**
+ * Request price of one ordered image occurrence under one exact model route's
+ * request projection. Every occurrence resolves to the pair the wire actually
+ * carries: provider visual tokens for a retained image, plus the model-visible
+ * text sent with or instead of it (request-preview handle, offload placeholder,
+ * or text-only substitution). The caller prices `text` with its own text
+ * estimator so provider pricing never fixes a text tokenization.
+ */
+interface LlmImageRequestPrice {
+  /** Provider visual tokens for the retained request image; 0 when only text represents this occurrence. */
+  visualTokens: number;
+  /** Model-visible text sent for this occurrence, to be priced by the caller's text estimator. */
+  text: string;
+}
+/**
+ * Provider-side request-image pricing for one exact model route. Implemented
+ * by adapters whose provider charges visual tokens; consumers (the token
+ * meter) resolve it synchronously per measurement, so implementations must not
+ * perform I/O.
+ */
+interface LlmImageRequestPricing {
+  /**
+   * Price every image occurrence of one request projection.
+   * @param images - durable image references in request order, one entry per occurrence.
+   * @returns one price per occurrence, aligned by index with `images`.
+   */
+  priceImages(images: readonly ImageAttachmentRef[]): readonly LlmImageRequestPrice[];
+}
+/** Display metadata for one registered provider route. */
+interface LlmProviderInfo {
+  /** Provider route key used by {@link GenerateOptions.provider}. */
+  id: string;
+  /** Human-readable provider name for selectors and diagnostics. */
+  name: string;
+}
+/** Merge-extensible provider model modality vocabulary. */
+interface ModelModalityMap {
+  text: 'text';
+  image: 'image';
+}
+/** Any declared provider model modality. */
+type ModelModality = ModelModalityMap[keyof ModelModalityMap];
+/**
+ * One provider route an adapter plugin can activate through configuration,
+ * whether or not the route is currently registered. Configuration surfaces
+ * merge this directory with `listProviders()` to offer every configurable
+ * provider alongside its live/dormant state.
+ */
+interface LlmConfigurableProvider {
+  /** Provider route key this entry activates when configured. */
+  provider: string;
+  /** Human-readable provider name for configuration surfaces. */
+  displayName: string;
+  /** User-settings namespace whose section configures this provider. */
+  settingsNs: string;
+  /**
+   * Path from that namespace's section root to this provider's profile
+   * object; empty when the whole section is the profile.
+   */
+  settingsPath: readonly string[];
+  /**
+   * Whether the owning adapter knows this route only because configuration
+   * declared it — a gateway or self-hosted server it ships nothing about.
+   * Absent means the adapter draws no such distinction; false means it does
+   * and this route is one of its own. Only the adapter can answer: a stored
+   * profile is how a user-added route AND a corrected shipped one both look
+   * from outside.
+   */
+  declared?: boolean;
+  /** Configuration diagnostic for repair; unaffected models may remain serviceable. */
+  error?: string;
+}
+/**
+ * One interrogation of a provider endpoint that configuration has not stored
+ * yet. Configuration surfaces send the draft a user is still editing, so the
+ * request carries the endpoint and credential directly instead of naming a
+ * route: a provider being added has no route to name.
+ */
+interface LlmModelDiscoveryRequest {
+  /**
+   * Route the draft is editing, when it edits an existing one. A route whose
+   * adapter already knows its models answers from that knowledge instead of
+   * asking the endpoint — the adapter's own registry is the better answer, and
+   * it costs no network call.
+   */
+  provider?: string;
+  /**
+   * Endpoint to interrogate. Optional because a route the adapter already
+   * describes needs none; a route it does not must supply one.
+   */
+  baseURL?: string;
+  /** Wire protocol the endpoint speaks, when the draft names one. */
+  api?: string;
+  /** Credential for this interrogation alone; the harness never stores it. */
+  apiKey?: string;
+}
+declare module '@deepseek-ai/dsh-typert-protocol' {
+  interface RemoteErrorDetailsMap {
+    /** A draft provider interrogation refused or failed. */
+    'llm/model-discovery-rejected': {
+      readonly settingsNs: string;
+      readonly baseURL?: string;
+    };
+  }
+}
+/**
+ * One model an endpoint reports about itself. Every field but the id is
+ * optional because most provider listings disclose an id and nothing else;
+ * a surface adopting one of these still owes the capacities its adapter needs.
+ */
+interface LlmDiscoveredModel {
+  /** Model id the endpoint accepts. */
+  id: string;
+  /** Human-readable name when the endpoint supplies one. */
+  name?: string;
+  /** Maximum combined request and response context, when disclosed. */
+  contextWindow?: number;
+  /** Maximum output tokens, when disclosed. */
+  maxTokens?: number;
+}
+/** One adapter-discovered model; catalog membership is advisory, not request validation. */
+interface LlmModelInfo {
+  /** Provider route that owns this model entry. */
+  provider: string;
+  /** Model id passed to {@link GenerateOptions.model}. */
+  id: string;
+  /** Human-readable model name for selectors. */
+  name: string;
+  /** Optional user-facing distinction from otherwise similar models. */
+  description?: string;
+  /** Accepted request modalities; absent means unknown, while an explicit omission is negative capability. */
+  inputModalities?: readonly ModelModality[];
+}
+/** Provider-owned context capacity for one exact provider/model route. */
+interface LlmModelContext {
+  /** Maximum combined request and response context in tokens. */
+  contextWindow: number;
+}
+/** Display metadata for one adapter-owned reasoning effort. */
+interface LlmReasoningEffortInfo {
+  /** Opaque stable value accepted by {@link GenerateOptions.reasoningEffort}. */
+  id: ReasoningEffortId;
+  /** Human-readable effort name for selectors and diagnostics. */
+  name: string;
+  /** Optional user-facing distinction from otherwise similar efforts. */
+  description?: string;
+}
+/** Selectable reasoning efforts for one exact provider/model route. */
+interface LlmModelReasoningInfo {
+  /** Supported efforts in adapter-preferred display order. */
+  efforts: readonly LlmReasoningEffortInfo[];
+  /**
+   * Adapter-configured default materialized into requests when callers omit
+   * an effort. Absence preserves the provider's own default.
+   */
+  defaultEffort?: ReasoningEffortId;
+}
+/**
+ * How a model applies a system prompt that changes mid-conversation.
+ * `'in-history'`: the model reads the latest `system` message at any position
+ * of `messages` as the complete effective system prompt, so a changed prompt
+ * can follow the cached history instead of rewriting message 0.
+ */
+type SystemPromptUpdate = 'in-history';
+/** Exact-route model metadata resolved by its owning adapter. */
+interface LlmResolvedModelInfo extends LlmModelInfo {
+  /** Provider-owned context capacity when known. */
+  context?: LlmModelContext;
+  /** Adapter-configured per-request output cap materialized when callers omit one. */
+  defaultMaxTokens?: number;
+  /** Adapter-owned selectable reasoning levels when exposed. */
+  reasoning?: LlmModelReasoningInfo;
+  /** Declared mid-conversation system prompt handling; absent means only a leading system message is read. */
+  systemPromptUpdate?: SystemPromptUpdate;
+}
+/**
+ * Adapter-private lossless-JSON state for replaying a successful response,
+ * carried by a terminal `finish` chunk and stored on the assembled assistant
+ * message's model source. Both halves stay opaque to the harness; only the
+ * split is shared vocabulary, so assembly can keep stored metadata aligned
+ * with stored content without reading either half.
+ */
+interface ReplayEnvelope {
+  /** Response-level adapter-private metadata (ids, native stop reason). */
+  response: unknown;
+  /**
+   * Per-block adapter-private metadata, one entry per emitted block in
+   * first-seen stream order. When assembly drops a block it drops the entry at
+   * the same position; entries whose length does not match the emitted block
+   * count discard the whole envelope. An adapter whose metadata is independent
+   * of block structure omits this field and the envelope passes through
+   * assembly unchanged.
+   */
+  blocks?: readonly unknown[];
+}
+/**
+ * Raw streaming protocol emitted by adapters.
+ * Block indexes correlate interleaved deltas, and `block-end` carries the
+ * assembled block. Adapters emit usage before the terminal finish and nothing
+ * afterward; tool arguments remain raw JSON strings. An adapter implementation
+ * may throw, but `LlmRuntime.stream()` normalizes that failure to a terminal
+ * `error` or `aborted` finish before exposing it to consumers.
+ */
+type StreamChunk = {
+  type: 'block-start';
+  index: number;
+  blockType: ContentBlockType;
+} | {
+  type: 'text-delta';
+  index: number;
+  text: string;
+} | {
+  type: 'reasoning-delta';
+  index: number;
+  text: string;
+} | {
+  type: 'tool-call-delta';
+  index: number;
+  id: ToolCallId;
+  name?: string;
+  argumentsDelta: string;
+} | {
+  type: 'block-end';
+  index: number;
+  block: ContentBlock;
+} | {
+  type: 'usage';
+  usage: TokenUsage;
+} | {
+  type: 'finish';
+  reason: FinishReason;
+  /** Replay metadata for a successful response; see {@link ReplayEnvelope}. */
+  replayState?: ReplayEnvelope;
+};
+/**
+ * JSON-schema description of a tool, as sent to the model.
+ *
+ * Declared here (not in dsh-tools) because it is part of {@link GenerateOptions};
+ * dsh-tools' ToolDefinition and dsh-system-prompt's PromptAssembly both import
+ * it from this package.
+ */
+interface ToolSchema {
+  name: string;
+  description: string;
+  /** JSON Schema object for the arguments. */
+  parameters: Record<string, unknown>;
+}
+/** A single model request, fully assembled. */
+interface GenerateOptions {
+  /** Registered provider route selecting the adapter instance. */
+  provider: string;
+  model: string;
+  /** Adapter-owned reasoning effort selected for this exact model. */
+  reasoningEffort?: ReasoningEffortId;
+  /**
+   * Ordered conversation messages, exactly as the provider sees them. A
+   * loop-built request passes the derived history (dsh-agent-loop), whose
+   * leading system-role message carries the system prompt; a hand-built
+   * one-shot passes any list.
+   */
+  messages: Message[];
+  /**
+   * System prompt text for one-shot callers; adapters map it to the provider's
+   * system slot ahead of `messages`. Loop-built requests leave it undefined.
+   */
+  system?: string;
+  /** Tool schemas (adapters map to the provider's `tools` field). */
+  tools?: ToolSchema[];
+  temperature?: number;
+  maxTokens?: number;
+  /**
+   * Stop sequences: generation halts as soon as the model produces any one of
+   * these strings (adapters map to the provider's stop field, e.g. OpenAI
+   * `stop`). The stop string itself is not included in the output.
+   */
+  stop?: string[];
+  signal?: AbortSignal;
+  /**
+   * Session identity stamped by the loop for request routing. Replay uses it
+   * to separate cursors; adapters may map it to model-hidden transport metadata.
+   */
+  sessionId?: Branded<'SessionId'>;
+  /**
+   * Provider-neutral classification for an auxiliary model call. Adapters may
+   * map the purpose to model-hidden transport metadata or purpose-specific
+   * generation policy. Ordinary conversation requests leave it unset.
+   */
+  purpose?: 'compaction' | 'session-title';
+}
+//#endregion
+//#region ../../node_modules/@deepseek-ai/cosmokit/lib/types/types.d.ts
+declare function isArrayBufferLike(value: any): value is ArrayBufferLike;
+declare function isArrayBufferSource(value: any): value is Binary.Source;
+/** Binary source detection and base64/hex conversion helpers. */
+declare namespace Binary {
+  type Source<T extends ArrayBufferLike = ArrayBufferLike> = T | ArrayBufferView<T>;
+  const is: typeof isArrayBufferLike;
+  const isSource: typeof isArrayBufferSource;
+  function fromSource<T extends ArrayBufferLike>(source: Source<T>): T;
+  function toBase64(source: Source): string;
+  function fromBase64(source: string): ArrayBuffer | Uint8Array<ArrayBuffer>;
+  function toHex(source: Source): string;
+  function fromHex(source: string): ArrayBuffer;
+}
+//#endregion
+//#region ../../node_modules/@deepseek-ai/cosmokit/lib/types/misc.d.ts
+/** String/symbol keyed dictionary type. */
+type Dict<T = any, K extends string | symbol = string> = { [key in K]: T; };
+//#endregion
+//#region ../../node_modules/@standard-schema/spec/dist/index.d.ts
+/** The Standard Typed interface. This is a base type extended by other specs. */
+interface StandardTypedV1<Input = unknown, Output = Input> {
+  /** The Standard properties. */
+  readonly "~standard": StandardTypedV1.Props<Input, Output>;
+}
+declare namespace StandardTypedV1 {
+  /** The Standard Typed properties interface. */
+  interface Props<Input = unknown, Output = Input> {
+    /** The version number of the standard. */
+    readonly version: 1;
+    /** The vendor name of the schema library. */
+    readonly vendor: string;
+    /** Inferred types associated with the schema. */
+    readonly types?: Types<Input, Output> | undefined;
+  }
+  /** The Standard Typed types interface. */
+  interface Types<Input = unknown, Output = Input> {
+    /** The input type of the schema. */
+    readonly input: Input;
+    /** The output type of the schema. */
+    readonly output: Output;
+  }
+  /** Infers the input type of a Standard Typed. */
+  type InferInput<Schema extends StandardTypedV1> = NonNullable<Schema["~standard"]["types"]>["input"];
+  /** Infers the output type of a Standard Typed. */
+  type InferOutput<Schema extends StandardTypedV1> = NonNullable<Schema["~standard"]["types"]>["output"];
+}
+/** The Standard Schema interface. */
+interface StandardSchemaV1<Input = unknown, Output = Input> {
+  /** The Standard Schema properties. */
+  readonly "~standard": StandardSchemaV1.Props<Input, Output>;
+}
+declare namespace StandardSchemaV1 {
+  /** The Standard Schema properties interface. */
+  interface Props<Input = unknown, Output = Input> extends StandardTypedV1.Props<Input, Output> {
+    /** Validates unknown input values. */
+    readonly validate: (value: unknown, options?: StandardSchemaV1.Options | undefined) => Result<Output> | Promise<Result<Output>>;
+  }
+  /** The result interface of the validate function. */
+  type Result<Output> = SuccessResult<Output> | FailureResult;
+  /** The result interface if validation succeeds. */
+  interface SuccessResult<Output> {
+    /** The typed output value. */
+    readonly value: Output;
+    /** A falsy value for `issues` indicates success. */
+    readonly issues?: undefined;
+  }
+  interface Options {
+    /** Explicit support for additional vendor-specific parameters, if needed. */
+    readonly libraryOptions?: Record<string, unknown> | undefined;
+  }
+  /** The result interface if validation fails. */
+  interface FailureResult {
+    /** The issues of failed validation. */
+    readonly issues: ReadonlyArray<Issue>;
+  }
+  /** The issue interface of the failure output. */
+  interface Issue {
+    /** The error message of the issue. */
+    readonly message: string;
+    /** The path of the issue, if any. */
+    readonly path?: ReadonlyArray<PropertyKey | PathSegment> | undefined;
+  }
+  /** The path segment interface of the issue. */
+  interface PathSegment {
+    /** The key representing a path segment. */
+    readonly key: PropertyKey;
+  }
+  /** The Standard types interface. */
+  interface Types<Input = unknown, Output = Input> extends StandardTypedV1.Types<Input, Output> {}
+  /** Infers the input type of a Standard. */
+  type InferInput<Schema extends StandardTypedV1> = StandardTypedV1.InferInput<Schema>;
+  /** Infers the output type of a Standard. */
+  type InferOutput<Schema extends StandardTypedV1> = StandardTypedV1.InferOutput<Schema>;
+}
+//#endregion
+//#region ../../node_modules/@deepseek-ai/schemastery/lib/types/index.d.ts
+declare const kSchema: unique symbol;
+declare global {
+  namespace Schemastery {
+    /** Convert primitive constructors, constants, and existing schemas into a schema type. */
+    type From<X> = X extends string | number | boolean ? Schema<X> : X extends Schema ? X : X extends typeof String ? Schema<string> : X extends typeof Number ? Schema<number> : X extends typeof Boolean ? Schema<boolean> : X extends typeof Function ? Schema<Function, (...args: any[]) => any> : X extends Constructor<infer S> ? Schema<S> : never;
+    type TypeS1<X> = X extends Schema<infer S, unknown> ? S : never;
+    type Inverse<X> = X extends Schema<any, infer Y> ? (arg: Y) => void : never;
+    /** Input type accepted by a schema-like value. */
+    type TypeS<X> = TypeS1<From<X>>;
+    /** Output type returned by a schema-like value after validation. */
+    type TypeT<X> = ReturnType<From<X>>;
+    /** Resolver callback used by custom schema types registered with `Schema.extend()`. */
+    type Resolve = (data: any, schema: Schema, options: Options, strict?: boolean) => [any, any?];
+    /** Input type accepted by one schema in an intersection. */
+    type IntersectS<X> = From<X> extends Schema<infer S, unknown> ? S : never;
+    /** Output type returned by one schema in an intersection. */
+    type IntersectT<X> = Inverse<From<X>> extends ((arg: infer T) => void) ? T : never;
+    type TupleS<X extends readonly any[]> = X extends readonly [infer L, ...infer R] ? [TypeS<L>?, ...TupleS<R>] : any[];
+    type TupleT<X extends readonly any[]> = X extends readonly [infer L, ...infer R] ? [TypeT<L>?, ...TupleT<R>] : any[];
+    type ObjectS<X extends Dict> = { [K in keyof X]?: TypeS<X[K]> | null; } & Dict;
+    type ObjectT<X extends Dict> = { [K in keyof X]: TypeT<X[K]>; } & Dict;
+    type Constructor<T = any> = new (...args: any[]) => T;
+    /** Static constructor and factory methods exposed by the default `Schema` export. */
+    interface Static {
+      <T = any>(options: Partial<Schema<T>>): Schema<T>;
+      new <T = any>(options: Partial<Schema<T>>): Schema<T>;
+      prototype: Schema;
+      /** Validate a value against a schema node and return `[output, adaptedInput?]`. */
+      resolve: Resolve;
+      /** Infer a schema from a primitive value, constructor, or existing schema. */
+      from<X = any>(source?: X): From<X>;
+      /** Register a resolver for a custom schema `type`. */
+      extend(type: string, resolve: Resolve): void;
+      /** Accept any value without validation. */
+      any<T = any>(): Schema<T>;
+      /** Accept only nullable input. */
+      never(): Schema<never>;
+      /** Accept exactly one constant value. */
+      const<const T>(value: T): Schema<T>;
+      /** Accept strings, with optional metadata constraints added by instance methods. */
+      string(): Schema<string>;
+      /** Accept numbers, with optional range and step constraints. */
+      number(): Schema<number>;
+      /** Accept non-negative integer numbers. */
+      natural(): Schema<number>;
+      /** Accept a number between 0 and 1 and mark it as a slider. */
+      percent(): Schema<number>;
+      /** Accept booleans. */
+      boolean(): Schema<boolean>;
+      /** Accept `Date` instances or parse datetime strings into `Date` objects. */
+      date(): Schema<string | Date, Date>;
+      /** Accept `RegExp` instances or parse strings into regular expressions. */
+      regExp(flag?: string): Schema<string | RegExp, RegExp>;
+      /** Accept binary sources and normalize them to `ArrayBufferLike`. */
+      arrayBuffer(): Schema<Binary.Source, ArrayBufferLike>;
+      arrayBuffer(encoding: 'hex' | 'base64'): Schema<Binary.Source | string, ArrayBufferLike>;
+      /** Accept a numeric bitset or string keys and normalize to a number. */
+      bitset<K extends string>(bits: Partial<Record<K, number>>): Schema<number | readonly K[], number>;
+      /** Accept functions. */
+      function(): Schema<Function, (...args: any[]) => any>;
+      /** Accept instances of a constructor or objects whose constructor name matches. */
+      is(constructor: string): Schema;
+      is<T>(constructor: Constructor<T>): Schema<T>;
+      /** Accept arrays whose elements match `inner`. */
+      array<X>(inner: X): Schema<TypeS<X>[], TypeT<X>[]>;
+      /** Accept plain objects with values matching `inner` and optional key schema. */
+      dict<X, Y extends Schema<any, string> = Schema<string>>(inner: X, sKey?: Y): Schema<Dict<TypeS<X>, TypeS<Y>>, Dict<TypeT<X>, TypeT<Y>>>;
+      /** Accept tuple arrays where each index matches the corresponding schema. */
+      tuple<const X extends readonly any[]>(list: X): Schema<TupleS<X>, TupleT<X>>;
+      /** Accept plain objects whose declared properties match the schema dictionary. */
+      object<X extends Dict>(dict: X): Schema<ObjectS<X>, ObjectT<X>>;
+      /** Accept values matching at least one schema in `list`. */
+      union<const X>(list: readonly X[]): Schema<TypeS<X>, TypeT<X>>;
+      /** Accept values matching every schema in `list`, merging object outputs. */
+      intersect<const X>(list: readonly X[]): Schema<IntersectS<X>, IntersectT<X>>;
+      /** Validate with `inner`, then convert the result with `callback`. */
+      transform<X, T>(inner: X, callback: (value: TypeS<X>, options: Schemastery.Options) => T, preserve?: boolean): Schema<TypeS<X>, T>;
+      /** Defer construction of a recursive schema until validation or serialization. */
+      lazy<X extends Schema>(callback: () => X): X;
+      ValidationError: typeof ValidationError;
+    }
+    /** Runtime validation options shared by all schema calls. */
+    interface Options {
+      /** Remove invalid object properties instead of throwing when possible. */
+      autofix?: boolean;
+      /** Skip validation for selected values and schema nodes. */
+      ignore?(data: any, schema: Schema): boolean;
+      /** Path used to format nested validation errors. */
+      path?: (keyof any)[];
+    }
+    /** UI and validation metadata attached by schema builder methods. */
+    interface Meta<T = any> {
+      default?: T extends {} ? Partial<T> : T;
+      required?: boolean;
+      disabled?: boolean;
+      collapse?: boolean;
+      badges?: {
+        text: string;
+        type: string;
+      }[];
+      hidden?: boolean;
+      loose?: boolean;
+      role?: string;
+      extra?: any;
+      link?: string;
+      description?: string | Dict<string>;
+      comment?: string;
+      pattern?: {
+        source: string;
+        flags?: string;
+      };
+      max?: number;
+      min?: number;
+      step?: number;
+    }
+  }
+  /** Callable schema instance that validates input and returns normalized output. */
+  interface Schemastery<S = any, T = S> {
+    (data?: S | null, options?: Schemastery.Options): T;
+    new (data?: S | null, options?: Schemastery.Options): T;
+    [kSchema]: true;
+    uid: number;
+    meta: Schemastery.Meta<T>;
+    type: string;
+    sKey?: Schema;
+    inner?: Schema;
+    list?: Schema[];
+    dict?: Dict<Schema>;
+    bits?: Dict<number>;
+    callback?: Function;
+    constructor?: string | Function;
+    builder?: Function;
+    value?: T;
+    refs?: Dict<Schema>;
+    preserve?: boolean;
+    '~standard': StandardSchemaV1.Props;
+    /** Format this schema as a compact TypeScript-like type string. */
+    toString(inline?: boolean): string;
+    /** Serialize this schema, preserving shared and recursive references. */
+    toJSON(): Schema<S, T>;
+    /** Mark nullable input as invalid unless a default supplies a fallback. */
+    required(value?: boolean): Schema<S, T>;
+    /** Hide this schema node from UI renderers. */
+    hidden(value?: boolean): Schema<S, T>;
+    /** Return the default value instead of throwing when validation fails. */
+    loose(value?: boolean): Schema<S, T>;
+    /** Attach a renderer role and optional role-specific metadata. */
+    role(text: string, extra?: any): Schema<S, T>;
+    /** Attach an external documentation link. */
+    link(link: string): Schema<S, T>;
+    /** Set the fallback value used for nullable input. */
+    default(value: T): Schema<S, T>;
+    /** Attach an auxiliary comment for documentation or form UIs. */
+    comment(text: string): Schema<S, T>;
+    /** Attach a localized or plain description for documentation or form UIs. */
+    description(text: string): Schema<S, T>;
+    /** Mark this schema node as disabled for form UIs. */
+    disabled(value?: boolean): Schema<S, T>;
+    /** Request collapsed rendering for nested form UIs. */
+    collapse(value?: boolean): Schema<S, T>;
+    /** Add a deprecated badge to this schema node. */
+    deprecated(): Schema<S, T>;
+    /** Add an experimental badge to this schema node. */
+    experimental(): Schema<S, T>;
+    /** Require strings to match a regular expression. */
+    pattern(regexp: RegExp): Schema<S, T>;
+    /** Set an inclusive maximum for numbers or collection lengths. */
+    max(value: number): Schema<S, T>;
+    /** Set an inclusive minimum for numbers or collection lengths. */
+    min(value: number): Schema<S, T>;
+    /** Set the numeric increment constraint. */
+    step(value: number): Schema<S, T>;
+    /** Add or replace an object property schema. */
+    set(key: string, value: Schema): Schema<S, T>;
+    /** Append a tuple, union, or intersection member schema. */
+    push(value: Schema): Schema<S, T>;
+    /** Remove values equal to schema defaults from normalized output. */
+    simplify(value?: any): any;
+    /** Return a schema clone with descriptions merged from locale messages. */
+    i18n(messages: Dict): Schema<S, T>;
+    /** Attach arbitrary metadata consumed by form renderers and downstream tools. */
+    extra<K extends keyof Schemastery.Meta>(key: K, value: Schemastery.Meta[K]): Schema<S, T>;
+  }
+}
+declare class ValidationError extends TypeError {
+  options: Schemastery.Options;
+  name: string;
+  constructor(message: string, options: Schemastery.Options);
+  static is(error: any): error is ValidationError;
+}
+type Schema<S = any, T = S> = Schemastery<S, T>;
+declare const Schema: Schemastery.Static;
+//#endregion
+//#region ../../node_modules/@deepseek-ai/dsh-llm/lib/types/retry-policy.d.ts
+/** Fully resolved backoff shared by both retry modes. */
+interface ResolvedRetryBackoff {
+  readonly initialDelayMs: number;
+  readonly maxDelayMs: number;
+  readonly jitterRatio: number;
+}
+/** Fully resolved bounded transient retry policy. */
+interface ResolvedNormalRetryPolicy extends ResolvedRetryBackoff {
+  readonly mode: 'normal';
+  readonly maxRetries: number;
+  readonly retryableCodes: readonly string[];
+}
+/** Fully resolved unbounded retry policy. */
+interface ResolvedAlwaysRetryPolicy extends ResolvedRetryBackoff {
+  readonly mode: 'always';
+}
+/** Immutable provider policy captured when its adapter route is registered. */
+type ResolvedRetryPolicy = ResolvedNormalRetryPolicy | ResolvedAlwaysRetryPolicy;
+//#endregion
+//#region ../../node_modules/@deepseek-ai/dsh-llm/lib/types/call-config.d.ts
+/**
+ * Provider, model, reasoning effort, and sampling scalars of one conversation's
+ * requests. Every field maps 1:1 onto the same-named `GenerateOptions` field;
+ * the loop builds requests from the logged header rather than accepting these
+ * per call.
+ */
+interface LlmCallConfig {
+  provider: string;
+  model: string;
+  reasoningEffort?: ReasoningEffortId;
+  temperature?: number;
+  maxTokens?: number;
+  stop?: string[];
+}
+/**
+ * Effective config fields supplied by exact-model adapter resolution rather
+ * than by the caller's request proposal.
+ */
+interface LlmCallConfigAdapterDefaults {
+  reasoningEffort?: true;
+  maxTokens?: true;
+}
+//#endregion
+//#region ../../node_modules/@deepseek-ai/dsh-llm/lib/types/index.d.ts
+declare module '@deepseek-ai/cordis' {
+  interface Context {
+    llm: LlmRuntime;
+  }
+  interface Events {
+    /**
+     * Waterfall around every streaming model call (retry, replay, routing).
+     * Bound to the {@link LlmRuntime}; call `next()` to reach the resolved
+     * adapter's stream, or yield your own chunks to short-circuit.
+     * @param options - the full request. A LOOP-built request carries the
+     *   process-local {@link markAgentLoopRequest} identity and arrives deep-frozen
+     *   (mutation throws): its content is a pure function of the session log (the
+     *   reconstructability Agent Note), so listeners read it, never rewrite it.
+     *   Hand-built calls do not carry that marker; their messages already obey
+     *   the immutable creation contract.
+     * @mode waterfall
+     */
+    'llm/stream'(this: LlmRuntime, options: GenerateOptions, next: () => AsyncIterable<StreamChunk>): AsyncIterable<StreamChunk>;
+  }
+}
+/** One model call whose config and adapter registration were resolved together. */
+interface PreparedLlmCall {
+  /** Detached, deep-frozen config with any adapter-owned default materialized. */
+  readonly config: LlmCallConfig;
+  /** Immutable retry policy captured with the adapter registration. */
+  readonly retryPolicy: ResolvedRetryPolicy;
+  /** Detached context metadata resolved with the registration-bound call. */
+  readonly context?: LlmModelContext;
+  /** Exact model modalities captured with the adapter dispatch generation. */
+  readonly inputModalities?: readonly ModelModality[];
+  /** Exact model system prompt update mode captured with the adapter dispatch generation. */
+  readonly systemPromptUpdate?: SystemPromptUpdate;
+  /** Config fields materialized by the captured adapter rather than proposed by the caller. */
+  readonly adapterDefaults: LlmCallConfigAdapterDefaults;
+  /**
+   * Dispatch this call once through the registration captured during
+   * preparation. The request's call-config fields must match {@link config};
+   * reuse or mismatch fails with `INVALID_PREPARED_CALL`.
+   * @param options - fully assembled request carrying the prepared config.
+   * @returns the chunk stream, including the `llm/stream` waterfall.
+   */
+  stream(options: GenerateOptions): AsyncIterable<StreamChunk>;
+}
+/** One adapter-owned model-resolution generation bound to its eventual stream call. */
+interface PreparedAdapterCall {
+  /** Exact model metadata from the same adapter generation as {@link stream}. */
+  readonly model: LlmResolvedModelInfo;
+  /** Dispatch through that generation without re-reading dynamic connection facts. */
+  stream(options: GenerateOptions): AsyncIterable<StreamChunk>;
+}
+/**
+ * Provider-wire adapter for the harness message and stream vocabulary. Register implementations
+ * with `ctx.llm.registerAdapter(providers, adapter)`. Every provider HTTP request must include
+ * `attributionHeaders()`; prove the headers are added in the wire request or library header hook. The direct-fetch
+ * DeepSeek and library-backed pi-ai adapters meet this contract through different internals.
+ */
+declare abstract class LlmAdapter {
+  /**
+   * Describe one provider route owned by this adapter.
+   * @param provider - a route passed to `registerAdapter()` for this instance.
+   * @returns detached display metadata whose id must equal `provider`.
+   */
+  providerInfo(provider: string): LlmProviderInfo;
+  /**
+   * Return the provider-owned retry policy captured with this route.
+   * @param _provider - a route passed to `registerAdapter()` for this instance.
+   * @returns a resolved policy, or `undefined` to use the normal defaults.
+   */
+  providerRetryPolicy(_provider: string): ResolvedRetryPolicy | undefined;
+  /**
+   * Resolve provider-side request-image pricing for one exact model route.
+   * The default declares none, so consumers fall back to their own neutral
+   * estimate. Implementations must answer synchronously without I/O; the
+   * token meter resolves this per measurement.
+   * @param _provider - a route passed to `registerAdapter()` for this instance.
+   * @param _model - exact model id passed to {@link GenerateOptions.model}.
+   * @returns route-owned image pricing, or `undefined` when the route declares none.
+   */
+  imageRequestPricing(_provider: string, _model: string): LlmImageRequestPricing | undefined;
+  /**
+   * List models this adapter can currently advertise for one owned provider.
+   * The result is advisory: an adapter may accept unlisted model ids, and
+   * consumers must not turn absence into request rejection.
+   * @param _provider - one provider route owned by this adapter.
+   * @returns discoverable models in adapter-preferred order.
+   */
+  listModels(_provider: string): Promise<readonly LlmModelInfo[]>;
+  /**
+   * Resolve all metadata available for one exact model. This query is
+   * independent of the advisory catalog and does not validate request routing.
+   * @param provider - one provider route owned by this adapter.
+   * @param model - exact model id passed to {@link GenerateOptions.model}.
+   * @param _signal - cancellation for this exact-model lookup; asynchronous
+   *   implementations must settle promptly after it aborts.
+   * @returns provider/model identity plus any context, call-default, and reasoning metadata.
+   */
+  resolveModel(provider: string, model: string, _signal?: AbortSignal): Promise<LlmResolvedModelInfo>;
+  /**
+   * Bind exact model metadata and the eventual request dispatch to one adapter generation.
+   * Dynamic adapters override this so settings changes between preparation and
+   * dispatch cannot combine one generation's capabilities with another's endpoint.
+   * @param provider - registered provider route.
+   * @param model - exact model id.
+   * @param signal - cancellation for model resolution.
+   * @returns model metadata and a one-generation stream entry point.
+   */
+  prepareCall(provider: string, model: string, signal?: AbortSignal): Promise<PreparedAdapterCall>;
+  /**
+   * Stream one model call as raw chunks. The only required method.
+   * @param options - the fully-assembled request; implementations must honor `options.signal`.
+   * @returns the chunk stream, obeying the adapter contract documented on `StreamChunk`.
+   */
+  abstract stream(options: GenerateOptions): AsyncIterable<StreamChunk>;
+}
+/**
+ * What {@link LlmRuntime.registerAdapter} returns: the disposer, plus an
+ * atomic route replacement for the same adapter instance.
+ */
+interface AdapterRegistrationHandle {
+  /** Release every route this registration currently holds. */
+  (): void;
+  /**
+   * Replace this registration's routes with `providers`, keeping the same
+   * adapter instance. The candidate set is validated in full first — a
+   * conflict with another adapter, an invalid name, or bad provider metadata
+   * throws and leaves the current routes untouched — and the swap itself is
+   * one synchronous section, so no request can observe a gap. An empty array
+   * is legal here (a settings section that emptied holds zero routes while
+   * staying registered), unlike an empty initial registration.
+   *
+   * Throws `LlmError` with code `REGISTRATION_DISPOSED` once the registration
+   * has been released: its routes are gone and its disposer has already run,
+   * so anything registered afterwards would have no owner left to release it.
+   * @param providers - the complete next route set for this registration.
+   */
+  replace(providers: string[]): void;
+}
+/**
+ * A live configurable-provider registration, disposable and atomically
+ * replaceable — the directory counterpart of {@link AdapterRegistrationHandle}.
+ */
+interface DirectoryRegistrationHandle {
+  /** Withdraw every entry this registration currently holds. */
+  (): void;
+  /**
+   * Replace this registration's entries with `entries`. The candidate set is
+   * validated in full first — an entry another registration already declares,
+   * a duplicate within the set, or invalid metadata throws and leaves the
+   * current entries untouched — and the swap is one synchronous section, so no
+   * reader observes a gap. An empty array is legal here, unlike an empty
+   * initial registration.
+   *
+   * Throws `LlmError` with code `REGISTRATION_DISPOSED` once the registration
+   * has been disposed.
+   */
+  replace(entries: readonly LlmConfigurableProvider[]): void;
+}
+/**
+ * The abstract `llm` service: an adapter registry plus a streaming model-call
+ * API, interceptable via the `llm/stream` waterfall.
+ */
+declare class LlmRuntime extends TypertRemoteService {
+  private adapters;
+  private directory;
+  private discoveries;
+  constructor(ctx: Context);
+  /** Notify topology observers without letting one broken listener veto the commit. */
+  private emitAdaptersUpdated;
+  /** Contained-listener diagnostic shared by the sync and async failure paths. */
+  private warnAdaptersListenerFailure;
+  /**
+   * Register an adapter for the given provider routes. Throws `LlmError` with code
+   * `DUPLICATE_ADAPTER` if any provider already has an adapter (all-or-nothing).
+   * Disposed with the fiber.
+   * @param providers - every provider route this adapter should serve.
+   * @param adapter - the adapter that streams calls for those providers.
+   * @returns the disposer, carrying {@link AdapterRegistrationHandle.replace}.
+   */
+  registerAdapter(providers: string[], adapter: LlmAdapter): AdapterRegistrationHandle;
+  /**
+   * Validate one candidate route set for `adapter`, treating routes this
+   * registration already holds as available. Nothing is mutated: a rejected
+   * candidate leaves the registry exactly as it was.
+   */
+  private prepareRoutes;
+  /**
+   * Swap this registration's routes for the prepared ones in one synchronous
+   * section, so no observer can see the registry between the release and the
+   * re-registration. The route set's one mutation point is also where
+   * `llm/adapters-updated` is published, so a `replace` announces itself
+   * exactly like a first registration.
+   */
+  private commitRoutes;
+  /**
+   * Describe provider routes with a registered adapter.
+   * @returns detached provider metadata in registration order.
+   */
+  listProviders(): LlmProviderInfo[];
+  /**
+   * Declare provider routes an adapter plugin can activate through
+   * configuration. Registration is all-or-nothing: an empty list, invalid
+   * entry, or a provider already declared by any registration throws
+   * `LlmError` without registering the rest. Disposed with the fiber.
+   * @param entries - every configurable provider this plugin owns.
+   * @returns a handle that withdraws all of them, and can atomically replace them.
+   */
+  registerConfigurableProviders(entries: readonly LlmConfigurableProvider[]): DirectoryRegistrationHandle;
+  /**
+   * List every declared configurable provider, registered or dormant.
+   * @returns detached directory entries in declaration order.
+   */
+  listConfigurableProviders(): LlmConfigurableProvider[];
+  /**
+   * Offer to interrogate provider endpoints on behalf of the settings
+   * namespace this plugin owns. The namespace is the key because that is what
+   * a configuration surface already holds from the configurable-provider
+   * directory, and because a provider being *added* has no route to name yet.
+   * Disposed with the fiber.
+   * @param settingsNs - the namespace whose profiles this discovery serves.
+   * @param discover - interrogates one endpoint and must honor the supplied signal.
+   * @returns the disposer that withdraws the offer.
+   */
+  registerModelDiscovery(settingsNs: string, discover: (request: LlmModelDiscoveryRequest, signal?: AbortSignal) => Promise<readonly LlmDiscoveredModel[]>): () => void;
+  /**
+   * Interrogate one provider endpoint for the models it advertises. The
+   * request describes a draft, not a stored route, so nothing here reads or
+   * writes settings or credentials — the caller owns both, and the reply is
+   * candidate metadata a surface may offer for adoption.
+   * @param settingsNs - namespace whose registered discovery serves this draft.
+   * @param request - the endpoint, protocol, and one-shot credential to use.
+   * @param signal - caller cancellation.
+   * @returns the advertised models, deduplicated in endpoint order.
+   */
+  discoverModels(settingsNs: string, request: LlmModelDiscoveryRequest, signal?: AbortSignal): Promise<LlmDiscoveredModel[]>;
+  /**
+   * Remote adapter for one draft provider interrogation.
+   * @param settingsNs - namespace whose registered discovery serves this draft.
+   * @param request - endpoint, protocol, and one-shot credential to use.
+   * @param signal - caller cancellation supplied by the Remote carrier.
+   * @returns advertised models in endpoint order.
+   * @throws RemoteError with `llm/model-discovery-rejected` when discovery refuses or fails.
+   */
+  remoteDiscoverModels(settingsNs: string, request: LlmModelDiscoveryRequest, signal: AbortSignal): Promise<LlmDiscoveredModel[]>;
+  /**
+   * Resolve the retry policy captured when one provider route was registered.
+   * @param provider - registered provider route to inspect.
+   * @returns the provider-owned policy, with normal defaults already resolved.
+   */
+  providerRetryPolicy(provider: string): ResolvedRetryPolicy;
+  /**
+   * Resolve provider-side request-image pricing for one exact route, or
+   * `undefined` when the provider is unregistered or declares none. Unknown
+   * providers degrade to `undefined` rather than throwing because callers
+   * price durable history whose route may no longer be mounted.
+   * @param provider - provider route named by a request header.
+   * @param model - exact model id named by the same header.
+   * @returns the owning adapter's image pricing for the route, when declared.
+   */
+  imageRequestPricing(provider: string, model: string): LlmImageRequestPricing | undefined;
+  /**
+   * Resolve the exact text one durable file occurrence contributes to every
+   * provider request in the current execution environment.
+   * @param ref - durable verbatim file reference from model history.
+   * @returns the same deterministic handle text used at adapter dispatch.
+   */
+  fileRequestText(ref: FileAttachmentRef): string;
+  /** Detach typed adapter-owned modality metadata. */
+  private detachedModalities;
+  /**
+   * Discover models advertised by one registered provider. Catalog membership
+   * is advisory and never changes routing or request validation.
+   * @param provider - registered provider route to inspect.
+   * @returns detached model metadata in adapter-preferred order.
+   */
+  listModels(provider: string): Promise<LlmModelInfo[]>;
+  /**
+   * Resolve and validate all metadata from the adapter that owns one exact
+   * route. The result is detached from adapter-owned objects; catalog
+   * membership remains advisory and does not control request routing.
+   * @param provider - registered provider route to inspect.
+   * @param model - exact model id passed to the adapter.
+   * @param signal - optional cancellation for adapter-owned asynchronous lookup.
+   * @returns exact model identity plus available context and reasoning metadata.
+   */
+  resolveModelInfo(provider: string, model: string, signal?: AbortSignal): Promise<LlmResolvedModelInfo>;
+  private resolveModelInfoFor;
+  /** Validate and detach one adapter-returned exact model result. */
+  private normalizeModelInfo;
+  /**
+   * Validate a conversation call config against its exact model capability and
+   * materialize adapter-configured defaults. Unsupported explicit efforts
+   * reject before provider I/O; no clamping or aliasing is performed. This
+   * standalone query does not bind a later dispatch; use {@link prepareCall}
+   * when logging and streaming must share one adapter registration.
+   * @param config - provider/model route and optional request controls.
+   * @param signal - optional cancellation for adapter-owned capability lookup.
+   * @returns a detached config only when a default must be materialized.
+   */
+  resolveCallConfig(config: LlmCallConfig, signal?: AbortSignal): Promise<LlmCallConfig>;
+  private resolveCallFor;
+  /** Validate request controls against one already-bound exact model result. */
+  private resolveCallWithInfo;
+  /**
+   * Resolve one call under its current adapter registration. The returned
+   * one-shot handle keeps that registration across header logging and dispatch,
+   * so HMR cannot combine one adapter's capability result with another adapter.
+   * @param config - provider/model route and optional request controls.
+   * @param signal - optional cancellation for adapter-owned capability lookup.
+   * @returns a prepared config and its registration-bound stream entry point.
+   */
+  prepareCall(config: LlmCallConfig, signal?: AbortSignal): Promise<PreparedLlmCall>;
+  private registration;
+  /** Remove replay state whose historical route is owned by another adapter. */
+  private forAdapter;
+  /**
+   * Resolve the current execution-world read path of one durable file
+   * reference through the mounted attachment and filesystem providers.
+   */
+  private fileReadPath;
+  /**
+   * Final adapter boundary. Adapter selection, dispatch, iterator construction,
+   * and iteration failures become one terminal failure chunk. Middleware and
+   * downstream consumer failures remain thrown plugin or consumer errors.
+   */
+  private adapterStream;
+  /**
+   * Stream one model call as raw chunks (token-level deltas). Replay state is
+   * retained only when the same adapter instance owns its historical provider
+   * and the target provider. Final adapter selection remains fixed through
+   * asynchronous exact-model resolution and dispatch. Adapter selection,
+   * dispatch, and iteration failures become terminal `error` or `aborted`
+   * finish chunks; middleware, nested-call, cleanup, and consumer failures
+   * remain thrown.
+   * @param options - the full request; `options.provider` selects the adapter.
+   * @returns the chunk stream, possibly wrapped by `llm/stream` listeners.
+   */
+  stream(options: GenerateOptions): AsyncIterable<StreamChunk>;
+  private streamWithRegistration;
+}
+//#endregion
+//#region src/core/workspace-instruction-context.d.ts
+interface InstructionSnapshotResult {
+  snapshot: SessionInstructionSnapshot;
+  message: ReturnType<typeof createUserMessage> | undefined;
+}
+declare function escapeInstructionFrameBody(body: string): string;
+declare function renderInstructionMessageText(workspaceTitle: string, text: string): string;
+declare function createInstructionMessage(workspaceId: string, workspaceTitle: string, snapshot: SessionInstructionSnapshot): ReturnType<typeof createUserMessage>;
+interface AgentLike {
+  session: {
+    id: string;
+    header: {
+      cwd: string;
+    };
+    surface?: {
+      nodes?: number[];
+    };
+    eventAt?: (seq: number) => {
+      type: string;
+      data: {
+        source: {
+          kind: string;
+        };
+      };
+    } | undefined;
+  };
+}
+interface MessageLike {
+  id: string;
+  role: string;
+  source: {
+    kind: string;
+  };
+}
+interface WorkspaceRegistryLike {
+  resolveByPath(path: string): Promise<{
+    id: string;
+    path: string;
+    title: string;
+  } | undefined>;
+  get(id: string): {
+    id: string;
+    path: string;
+    title: string;
+  } | undefined;
+}
+declare function resolveSnapshotForSession(agent: AgentLike, messages: MessageLike[], workspaceStore?: WorkspaceInstructionStore, snapshotStore?: SessionInstructionSnapshotStore, registry?: WorkspaceRegistryLike): Promise<SessionInstructionSnapshot | undefined>;
+declare function registerWorkspaceInstructionInjector(ctx: Context): void;
+declare const name = "dshb-workspace-instruction-injector";
+declare const inject: string[];
+//#endregion
+export { InstructionSnapshotResult, createInstructionMessage, escapeInstructionFrameBody, inject, name, registerWorkspaceInstructionInjector, renderInstructionMessageText, resolveSnapshotForSession };
+//# sourceMappingURL=workspace-instruction-context.d.ts.map