@toddzheng024/dscode-bundle 0.7.5 → 0.7.7

package/vendor/pi-ai/types/config.d.ts

@@ -1,208 +0,0 @@
-/**
- * Configuration schema and provider-profile validation for the pi-ai adapter.
- * Profiles are a dict keyed by provider route, so the composition base and a
- * user-settings layer merge per provider and the route set is structural.
- *
- * A route key is not required to name an installed pi-ai provider. When it does,
- * that provider's endpoint, protocol, display name, and model catalog are the
- * profile's defaults and the profile overrides them field by field; when it does
- * not, the profile is the whole provider declaration. Stored reads retain
- * catalog diagnostics beside serviceable models; writes validate every changed
- * provider before persistence. Self-contained profile constraints apply to both.
- *
- * @module dsh-llm-pi-ai/config
- */
-import type { CacheRetention, ModelThinkingLevel, Provider, ThinkingBudgets, Transport } from '@earendil-works/pi-ai';
-import z from '@deepseek-ai/schemastery';
-import type { CredentialRef } from '@deepseek-ai/dsh-credentials';
-import type { ResolvedRetryPolicy, RetryPolicyConfig } from '@deepseek-ai/dsh-llm';
-import type { PiAiCompatProfile, PiAiModality, PiAiModelOverride, PiAiModelProfile } from './catalog.ts';
-/** Default maximum idle interval while an adapter stream read is outstanding. */
-export declare const DEFAULT_STREAM_IDLE_TIMEOUT_MS = 300000;
-/**
- * Default request-level bound on base64-encoded image payload. Every image in
- * history is re-encoded into every request body, so an unbounded conversation
- * eventually exceeds a provider or gateway request-size cap and the session
- * can never complete another request. The 20MiB default admits fifteen 1MiB
- * request versions after base64 expansion and reserves request capacity for
- * system prompts, history, tools, and JSON.
- * Deployments behind stricter gateways lower it per route.
- */
-export declare const DEFAULT_MAX_REQUEST_IMAGE_BYTES: number;
-/** Default total-pixel budget preserves the complete 2048px normalized attachment. */
-export declare const DEFAULT_REQUEST_IMAGE_PIXEL_BUDGET: number;
-/** Default raw encoded-byte target before inline base64 expansion; the smallest quality-ladder output is used when no quality fits. */
-export declare const DEFAULT_REQUEST_IMAGE_MAX_BYTES: number;
-/** Context capacity assumed for a model neither configuration nor the catalog sizes. */
-export declare const DEFAULT_CONTEXT_WINDOW = 262144;
-/** Output capability assumed for a model neither configuration nor the catalog sizes. */
-export declare const DEFAULT_MAX_TOKENS = 32768;
-/**
- * Modalities assumed for a model neither configuration nor the catalog
- * declares. Text is the floor every supported protocol certainly carries, so
- * this is the absence of a declaration rather than a guess at the endpoint:
- * nothing can interrogate a gateway for its modalities, and the two wrong
- * answers do not cost the same. Under-claiming refuses the image before it is
- * attached, naming the model. Over-claiming admits one the provider then
- * rejects mid-turn, after the message is durable, leaving the session
- * repeating a request that cannot succeed.
- */
-export declare const DEFAULT_INPUT: readonly PiAiModality[];
-export type { PiAiCompatProfile, PiAiModality, PiAiModelOverride, PiAiModelProfile, PiAiReasoningEfforts, PiAiThinkingFormat, } from './catalog.ts';
-/** Configuration for one pi-ai provider route; the `providers` dict key IS the route. */
-export interface PiAiProviderProfile {
-    /** Credential reference (environment-variable name) resolved per request through `ctx.credentials`. */
-    apiKeyEnv?: string;
-    /** Name shown by configuration surfaces; defaults to the route key. */
-    displayName?: string;
-    /**
-     * Wire protocol every model on this route speaks. Omission keeps each
-     * installed catalog model's own protocol, which is why a catalog route needs
-     * no protocol at all; a route the catalog does not ship must name one.
-     */
-    api?: string;
-    /** Endpoint for this route's models; defaults to the installed catalog's endpoint. */
-    baseURL?: string;
-    /**
-     * This route's model catalog. Omission serves the installed catalog for the
-     * route unchanged; an explicit list replaces it, each entry defaulting its
-     * unset fields from the installed model of the same id.
-     */
-    models?: PiAiModelProfile[];
-    /**
-     * Installed-catalog customizations by model id: each entry reshapes that
-     * one model with the same fields a {@link models} entry takes, while the
-     * rest of the catalog keeps serving untouched. Only meaningful on a catalog
-     * route with no `models` list — `models` already replaces the catalog, so
-     * an override beside it, on a route the catalog does not ship, or naming a
-     * model the catalog does not describe is refused rather than skipped.
-     */
-    modelOverrides?: Record<string, PiAiModelOverride>;
-    /**
-     * pi-ai wire-compatibility switches defaulting every model on this route
-     * whose protocol declares them; each model's own `compat` overrides per
-     * field. What neither sets keeps the installed catalog entry's value, then
-     * pi-ai's own detection. A switch no model on the route could read is
-     * refused rather than left looking applied.
-     */
-    compat?: PiAiCompatProfile;
-    /**
-     * Context capacity for a model this route lists that neither the entry nor
-     * the installed catalog sizes (default 262,144). A guess by construction, so
-     * a deployment whose gateway serves smaller models corrects it here.
-     */
-    defaultContextWindow?: number;
-    /**
-     * Output capability for a model this route lists that neither the entry nor
-     * the installed catalog sizes (default 32,768). This sizes the model; it
-     * never becomes a per-request cap on its own.
-     */
-    defaultMaxTokens?: number;
-    /**
-     * Request modalities for a model this route lists that neither its entry's
-     * {@link PiAiModelProfile.input} nor the installed catalog declares (default
-     * `[text]`). A fallback like the capacities above, not an override: a
-     * catalog model keeps the modalities the catalog records for it, and this
-     * value never narrows one. A gateway serving vision models the catalog does
-     * not describe declares `[text, image]` once here instead of on every entry.
-     * Unlike an entry's list, this one may not be empty — nothing sits below it
-     * to answer instead.
-     */
-    defaultInput?: PiAiModality[];
-    /** Provider request headers, validated against Fetch when the profile resolves; Harness attribution wins reserved names. */
-    headers?: Record<string, string>;
-    /** Provider-neutral pi-ai reasoning level. */
-    reasoning?: ModelThinkingLevel;
-    /** Token budgets used by reasoning providers that support them. */
-    thinkingBudgets?: ThinkingBudgets;
-    /** Prompt-cache retention preference. */
-    cacheRetention?: CacheRetention;
-    /** Streaming transport preference. */
-    transport?: Transport;
-    /** HTTP/provider SDK timeout in milliseconds. */
-    timeoutMs?: number;
-    /** WebSocket connection timeout in milliseconds. */
-    websocketConnectTimeoutMs?: number;
-    /** Maximum provider idle time while one stream read is outstanding. */
-    streamIdleTimeoutMs?: number;
-    /**
-     * Maximum base64-encoded image payload per request. When a request's
-     * accumulated images exceed it, the oldest images are replaced by text
-     * placeholders until the request fits, so a long session keeps completing
-     * requests instead of being rejected by a request-size cap.
-     */
-    maxRequestImageBytes?: number;
-    /** Total-pixel budget for each deterministic inline request version. */
-    requestImagePixelBudget?: number;
-    /**
-     * Raw encoded-byte target for each deterministic inline request version;
-     * the smallest quality-ladder output is used when no quality fits.
-     */
-    requestImageMaxBytes?: number;
-    /** Provider-owned model-request retry policy; omission uses normal mode with five retries. */
-    retryPolicy?: RetryPolicyConfig;
-}
-/** Validated profile with its route stamped and every adapter-owned default resolved. */
-export interface ResolvedPiAiProviderProfile extends Omit<PiAiProviderProfile, 'apiKeyEnv' | 'retryPolicy' | 'models' | 'displayName'> {
-    /** Harness route key and the `Models` collection key (the configuration dict key). */
-    provider: string;
-    /** Resolved display name for selectors and configuration surfaces. */
-    displayName: string;
-    /** Validated credential reference, when one is configured. */
-    apiKeyEnv?: CredentialRef;
-    /** Positive finite provider-idle interval after defaulting. */
-    streamIdleTimeoutMs: number;
-    /** Positive request-level base64 image payload bound after defaulting. */
-    maxRequestImageBytes: number;
-    /** Positive total-pixel request-version budget after defaulting. */
-    requestImagePixelBudget: number;
-    /** Positive raw request-version byte target after defaulting; the smallest quality-ladder output is used when no quality fits. */
-    requestImageMaxBytes: number;
-    /** Immutable retry policy captured with this provider route. */
-    retryPolicy: ResolvedRetryPolicy;
-    /**
-     * The pi-ai provider containing this route's serviceable models. Absent when
-     * a stored route cannot be constructed; its configuration remains editable.
-     */
-    piProvider?: Provider;
-    /** First model diagnostic, or the route failure when no model diagnostic is available. */
-    catalogError?: string;
-    /** Per-model failures reported before attempting a request. */
-    modelErrors: ReadonlyMap<string, string>;
-    /**
-     * Per-request output caps this profile explicitly configured, by model id.
-     * The seam materializes one only into a request that names no cap of its
-     * own, so a catalog capability must not appear here.
-     */
-    configuredMaxTokens: ReadonlyMap<string, number>;
-}
-/** Plugin configuration: the provider routes this instance owns. */
-export interface Config {
-    /**
-     * pi-ai provider routes, keyed by provider. An empty (or omitted) dict is
-     * the dormant settings-driven posture: the adapter mounts with no routes
-     * and registers them the moment a settings section supplies profiles.
-     */
-    providers?: Record<string, PiAiProviderProfile>;
-}
-/** Runtime schema for {@link Config}. */
-export declare const Config: z<Config>;
-/**
- * Reject new or changed provider profiles that cannot be served. Unchanged
- * stored profiles may need repair after a catalog upgrade and do not block
- * edits to another provider. Removed profiles require no catalog validation.
- * @param config - the resolved section to check.
- * @param previous - current resolved section; omission checks every provider.
- * @throws Error naming the route and configuration entry that cannot be served.
- */
-export declare function assertServiceable(config: Config, previous?: Config): void;
-/**
- * Resolve scalar defaults and materialize each route's serviceable models.
- * Deferred catalog validation retains diagnostics without deleting configured
- * routes. An omitted dict resolves to the empty, dormant route set.
- * @param providers - configured provider profiles keyed by route.
- * @param validation - writes require a complete catalog; stored reads retain catalog diagnostics.
- * @returns validated profiles in configuration order.
- */
-export declare function resolveProfiles(providers: Readonly<Record<string, PiAiProviderProfile>> | undefined, validation?: 'strict' | 'deferred'): Map<string, ResolvedPiAiProviderProfile>;
-//# sourceMappingURL=config.d.ts.map

package/vendor/pi-ai/types/context.d.ts

@@ -1,42 +0,0 @@
-/**
- * Harness request-history conversion into pi-ai's Context vocabulary.
- *
- * @module dsh-llm-pi-ai/context
- */
-import type { GenerateOptions, ImageAttachmentAccessResolver } from '@deepseek-ai/dsh-llm';
-import type { AttachmentStore, ImageRequestPolicy } from '@deepseek-ai/dsh-attachment';
-import type { Context as PiContext } from '@earendil-works/pi-ai';
-/** Inputs that bind deterministic request images to one current tool execution world. */
-export interface PiImageRequestContext {
-    /** Durable provider that resolves request-image bytes and provider-owned host objects. */
-    attachments: AttachmentStore;
-    /** Resolve current tool access separately from deterministic request-image versions. */
-    resolveImageAccess: ImageAttachmentAccessResolver;
-    /** Request-level bound on base64-encoded image payload; omission leaves every image in place. */
-    maxRequestImageBytes?: number;
-    /** Route pixel and raw encoded-byte budgets. */
-    requestImagePolicy?: ImageRequestPolicy;
-}
-/**
- * Convert text-only harness history to a synchronous pi-ai Context. Tool
- * result names are recovered from preceding assistant tool calls.
- * @param options - the harness request; `options.system`, else a leading `system` message, maps to pi-ai's single `systemPrompt` slot.
- * @param images - absent; selects the synchronous conversion.
- * @param onReplayDegrade - forwarded to {@link toPiAssistant} for each assistant message.
- * @returns the pi-ai context; `tools` is omitted when the request declares none.
- * @throws {LlmError} `UNSUPPORTED_CONTENT` for images in any history role, including a leading system message.
- */
-export declare function toPiContext(options: GenerateOptions, images?: undefined, onReplayDegrade?: (reason: string) => void): PiContext;
-/**
- * Convert harness history to a pi-ai Context while resolving durable images.
- * Tool result names are recovered from preceding assistant tool calls. When
- * the accumulated base64 image payload exceeds `maxRequestImageBytes`, the
- * oldest images are replaced by text placeholders until the request fits, so
- * an image-heavy session keeps clearing gateway request-size caps.
- * @param options - the harness request; `options.system`, else a leading `system` message, maps to pi-ai's single `systemPrompt` slot.
- * @param images - attachment provider, current path resolver, and request limits.
- * @param onReplayDegrade - forwarded to {@link toPiAssistant} for each assistant message.
- * @returns the asynchronously resolved pi-ai context.
- */
-export declare function toPiContext(options: GenerateOptions, images: PiImageRequestContext, onReplayDegrade?: (reason: string) => void): Promise<PiContext>;
-//# sourceMappingURL=context.d.ts.map

package/vendor/pi-ai/types/discovery.d.ts

@@ -1,43 +0,0 @@
-/**
- * Answering "which models can this provider serve?" for the configuration
- * surface's "fetch available models" action.
- *
- * A route the installed pi-ai catalog ships is answered **from that catalog**,
- * with no network call at all: pi-ai's registry is the authoritative list for
- * its own providers, and it carries the capacities a listing endpoint would
- * not disclose. Only a route the catalog does not describe — a gateway, a
- * self-hosted server — is interrogated over the wire.
- *
- * Neither path is a catalog refresh. Nothing here is stored: the request
- * carries a draft the user is still editing, and the reply is candidate
- * metadata the surface offers for adoption. `settings.yaml` remains the only
- * thing that decides what a route serves.
- *
- * OpenAI-compatible and Anthropic Messages protocols are interrogated through
- * their native model-listing endpoints. The parser accepts the standard
- * `data` array and the enriched `models` map some compatible gateways expose.
- * Every other protocol reports that it cannot be interrogated so the surface
- * falls back to hand-entry rather than guessing its response fields.
- *
- * @module dsh-llm-pi-ai/discovery
- */
-import type { LlmDiscoveredModel, LlmModelDiscoveryOperation } from '@deepseek-ai/dsh-llm';
-/** Host-owned profile inputs that a configuration draft deliberately omits. */
-export interface StoredModelDiscoveryProfile {
-    /** Deployment headers configured on the named route. */
-    readonly headers: Readonly<Record<string, string>> | undefined;
-    /** Resolve the named route's credential only when the draft carries none. */
-    readonly resolveApiKey: () => Promise<string | undefined>;
-}
-/**
- * Interrogate one draft provider endpoint for the models it advertises.
- * @param request - the endpoint, protocol, and one-shot credential to use.
- * @param storedProfile - Host-owned headers and lazy credential resolution for
- *   the named route. It is read only on the path that reaches the network; the
- *   credential is resolved only when the draft carries none.
- * @returns the advertised models in endpoint order.
- * @throws LlmError when the protocol has no readable listing, the endpoint
- *   refuses or fails the request, or the reply is not a model listing.
- */
-export declare function discoverModels(request: LlmModelDiscoveryOperation, storedProfile?: () => StoredModelDiscoveryProfile | undefined): Promise<readonly LlmDiscoveredModel[]>;
-//# sourceMappingURL=discovery.d.ts.map

package/vendor/pi-ai/types/index.d.ts

@@ -1,69 +0,0 @@
-/**
- * Generic pi-ai-backed LLM adapter plugin. One plugin instance owns a dict of
- * provider routes; a route naming an installed pi-ai provider inherits that
- * provider's endpoint, protocol, and model catalog as defaults, and a route
- * pi-ai does not ship is declared outright. Profile facts resolve per request
- * over the optional `llm-pi-ai` user-settings section and the optional
- * credential seam, so a changed key, endpoint, model, or knob reaches the next
- * request without a restart; a changed *route set* (or a route's
- * registration-captured retry policy) re-registers the same adapter instance
- * in place.
- *
- * ```yaml
- * - id: llm
- *   name: '@deepseek-ai/dsh-llm-pi-ai'
- *   config:
- *     providers:
- *       # Catalog route: everything but the credential comes from pi-ai.
- *       openai:
- *         apiKeyEnv: OPENAI_API_KEY
- *         retryPolicy:
- *           mode: normal
- *           maxRetries: 2
- *       # Catalog route with the catalog narrowed and one capacity corrected.
- *       anthropic:
- *         apiKeyEnv: ANTHROPIC_API_KEY
- *         models:
- *           - id: claude-sonnet-4-5
- *             contextWindow: 200000
- *       # Hand-declared route: pi-ai ships nothing under this key.
- *       acme-gateway:
- *         displayName: Acme Gateway
- *         apiKeyEnv: ACME_GATEWAY_API_KEY
- *         api: openai-completions
- *         baseURL: https://gateway.acme.example/v1
- *         # Reasoning dialect for a URL pi-ai cannot recognize.
- *         compat:
- *           thinkingFormat: deepseek
- *         models:
- *           - id: acme-large
- *             name: Acme Large
- *             contextWindow: 65536
- *             maxTokens: 4096
- *           - id: acme-think
- *             name: Acme Think
- *             contextWindow: 262144
- *             maxTokens: 32768
- *             # key = selectable level, value = wire spelling; only off may
- *             # leave the value empty (supported, send nothing).
- *             reasoningEfforts:
- *               off:
- *               high: high
- *               max: ultra
- * ```
- *
- * @module @deepseek-ai/dsh-llm-pi-ai
- */
-import type { Context } from '@deepseek-ai/cordis';
-import { Config } from './config.ts';
-export { PiAiAdapter } from './adapter.ts';
-export type { PiAiAdapterOptions } from './adapter.ts';
-export { Config } from './config.ts';
-export type { PiAiCompatProfile, PiAiModality, PiAiModelOverride, PiAiModelProfile, PiAiProviderProfile, PiAiReasoningEfforts, PiAiThinkingFormat, ResolvedPiAiProviderProfile, } from './config.ts';
-export { recordKeyFor } from './auth.ts';
-export { supportedProtocols } from './provider.ts';
-export declare const name = "llm-pi-ai";
-export declare const inject: string[];
-/** Register one generic pi-ai adapter for all configured provider routes. */
-export declare function apply(ctx: Context, config: Config): void;
-//# sourceMappingURL=index.d.ts.map

package/vendor/pi-ai/types/login.d.ts

@@ -1,21 +0,0 @@
-/**
- * Authorization flows for the pi-ai providers that ship a login. This is the
- * whole of the translation between the harness's neutral notice/prompt
- * vocabulary and pi-ai's `AuthInteraction`; nothing above it knows which
- * library ran the conversation.
- *
- * @module dsh-llm-pi-ai/login
- */
-import type { Context } from '@deepseek-ai/cordis';
-import type { PiAiAuthInjection } from './adapter.ts';
-/**
- * Register one authorization flow per installed provider that ships a login.
- *
- * Registration is unconditional on configuration: a provider has to be signed
- * into before a route for it is worth adding, so the flow exists from the
- * moment the plugin mounts rather than appearing once a profile does.
- * @param ctx - the plugin context carrying `ctx.authorization`.
- * @param auth - the injectables every collection here is built with.
- */
-export declare function registerPiAiFlows(ctx: Context, auth: PiAiAuthInjection): void;
-//# sourceMappingURL=login.d.ts.map

package/vendor/pi-ai/types/provider.d.ts

@@ -1,59 +0,0 @@
-/**
- * Construction of the pi-ai `Provider` that one configured route registers into
- * the adapter's `Models` collection.
- *
- * Two constructions, one decision: a route the installed catalog ships, whose
- * profile does not override the wire protocol, **reuses that catalog provider**
- * with its models replaced — the catalog provider owns API implementations this
- * package cannot reconstruct (Bedrock loads its Smithy module through a
- * separate entry point), so rebuilding it from parts would silently narrow
- * which providers work. Every other route — one pi-ai has never heard of, or a
- * catalog route pointed at a different protocol — is built by `createProvider`
- * over the protocol table below.
- *
- * Credentials never reach this module's storage: the harness resolves a route's
- * key through `ctx.credentials` before the request enters pi-ai and hands it
- * over as a stream option, which `Models` presents to `resolve()` as the
- * credential key.
- *
- * @module dsh-llm-pi-ai/provider
- */
-import type { Api, Model, Provider } from '@earendil-works/pi-ai';
-/**
- * Every wire protocol a configured route may name, most-reached first. The
- * order is the table's and therefore stable; a configuration surface offering
- * a choice presents the first as its default, which is why the protocol a
- * hand-declared gateway most often speaks — and the one endpoint interrogation
- * can read — leads.
- * @returns the supported protocol identifiers.
- */
-export declare function supportedProtocols(): readonly string[];
-/** The resolved route facts provider construction reads. */
-export interface ProviderSpec {
-    /** Provider route key; also the `Models` collection key and each model's `provider`. */
-    provider: string;
-    /** Display name for selectors and status labels. */
-    displayName: string;
-    /** Wire protocol override; absent means each model keeps its catalog protocol. */
-    api?: string;
-    /** Endpoint override already applied to {@link models}; kept for provider-level display. */
-    baseURL?: string;
-    /** The route's materialized models, in configuration order. */
-    models: readonly Model<Api>[];
-    /**
-     * Whether the profile names a credential, which it does through `apiKeyEnv`
-     * alone: configuration carries the reference, never the secret. Only that
-     * decides whether {@link routeAuth} adds the harness's own api-key method to
-     * a catalog provider that offers none; the key itself still arrives per
-     * request, never at construction.
-     */
-    namesCredential: boolean;
-}
-/**
- * Build the pi-ai provider for one resolved route.
- * @param spec - the resolved route facts.
- * @returns the provider to register in the adapter's `Models` collection.
- * @throws Error when the route names a wire protocol this build cannot serve.
- */
-export declare function buildProvider(spec: ProviderSpec): Provider;
-//# sourceMappingURL=provider.d.ts.map

package/vendor/pi-ai/types/replay.d.ts

@@ -1,63 +0,0 @@
-/**
- * Durable pi-ai replay metadata and assistant-history reconstruction.
- *
- * Harness content remains the durable source for text and tool calls. This
- * module stores only the provider-native metadata needed to reconstruct a
- * pi-ai assistant message on a later request.
- *
- * @module dsh-llm-pi-ai/replay
- */
-import type { Message, ReplayEnvelope } from '@deepseek-ai/dsh-llm';
-import type { Api, AssistantMessage } from '@earendil-works/pi-ai';
-/** Per-block half of the pi-ai replay envelope, one entry per content block. */
-export type PiAiReplayBlock = {
-    type: 'text';
-    textSignature?: string;
-} | {
-    type: 'reasoning';
-    thinkingSignature?: string;
-    redacted?: boolean;
-} | {
-    type: 'tool-call';
-    thoughtSignature?: string;
-};
-/** Versioned response-level half of the pi-ai replay envelope. */
-export interface PiAiReplayResponse {
-    kind: 'pi-ai';
-    version: 2;
-    api: Api;
-    provider: string;
-    /** Requested model identity, matching the durable assistant source. */
-    model: string;
-    /** Provider-reported model; only Anthropic replays it as the native model (reported in `message.model`, not `message.responseModel`). */
-    responseModel?: string;
-    responseId?: string;
-    /** Provider-native effort for historical replay; absence is preserved. */
-    providerThinkingLevel?: string;
-    stopReason: AssistantMessage['stopReason'];
-}
-/**
- * Project a successful pi-ai response into the minimal durable replay state.
- * The per-block half is index-aligned with the streamed blocks (pi-ai content
- * order), so `BlockAssembler` prunes an entry with its block whenever assembly
- * removes one.
- * @param message - completed native pi-ai assistant response.
- * @param requestedModel - request identity stored in the assistant source; defaults to the native model.
- * @returns the versioned lossless-JSON replay projection.
- */
-export declare function toPiReplayState(message: AssistantMessage, requestedModel?: string): ReplayEnvelope;
-/**
- * Convert one durable Harness assistant message into pi-ai history.
- *
- * Durable content is the authoritative record; replay metadata only restores
- * native fidelity (ids, signatures). A replay state this build cannot use —
- * another adapter's kind, another version, a malformed value, or metadata that
- * no longer matches the content — therefore degrades the one message to
- * provider-neutral history instead of failing the request.
- * @param message - assistant content with required source and optional adapter-owned replay metadata.
- * @param onDegrade - called with the diagnostic reason when an unusable replay
- *   state falls back to provider-neutral conversion.
- * @returns a native pi-ai assistant message reconstructed from durable content.
- */
-export declare function toPiAssistant(message: Message, onDegrade?: (reason: string) => void): AssistantMessage;
-//# sourceMappingURL=replay.d.ts.map

package/vendor/pi-ai/types/stream.d.ts

@@ -1,43 +0,0 @@
-/**
- * pi-ai assistant event translation into the Harness streaming protocol.
- *
- * pi-ai tool-call arguments are parsed objects while the Harness keeps their
- * raw JSON representation. pi-ai also reports failures as terminal stream
- * events, which this module maps into Harness finish chunks.
- *
- * @module dsh-llm-pi-ai/stream
- */
-import type { FinishReason, StreamChunk, TokenUsage } from '@deepseek-ai/dsh-llm';
-import type { AssistantMessage, AssistantMessageEvent, Usage as PiUsage } from '@earendil-works/pi-ai';
-/**
- * Map pi-ai usage (reasoning folded into output by pi-ai).
- * @param usage - cumulative usage from the terminal pi-ai event.
- * @returns harness counts with pi-ai's exact total; cache fields appear only
- *   when non-zero (pi-ai reports zeros, not absence).
- */
-export declare function mapUsage(usage: PiUsage): TokenUsage;
-/**
- * Map a terminal pi-ai event to the harness finish reason.
- * @param message - the assistant message carried by the `done` or `error` event.
- * @param contextWindow - resolved catalog capacity for usage-based overflow detection.
- * @returns the mapped harness reason. Recognized error text, `stop` usage above
- *   `contextWindow`, and zero-output `length` usage that fills the window map
- *   to `CONTEXT_WINDOW_EXCEEDED`; a `stop` with no content blocks maps to an
- *   `EMPTY_RESPONSE` error, while terminal `pending` and `deferred` states map
- *   to non-retryable `PI_AI_ERROR` failures.
- */
-export declare function mapStopReason(message: AssistantMessage, contextWindow?: number): FinishReason;
-/**
- * Translate the pi-ai event stream into StreamChunks. pi-ai never throws
- * mid-stream — failures arrive as `error` events, which become error/aborted
- * `finish` chunks (the harness protocol's other error-delivery style).
- * @param events - one assistant turn's pi-ai event stream.
- * @param contextWindow - resolved catalog capacity for usage-based overflow detection.
- * @param callerSignal - caller cancellation state; an aborted caller makes any
- *   in-band terminal error an aborted finish.
- * @param requestedModel - request model identity for durable replay provenance.
- * @returns the harness chunks, ending with `usage` then `finish`; throws
- *   `LlmError` (`STREAM_CLOSED`) if the source ends without a terminal event.
- */
-export declare function toStreamChunks(events: AsyncIterable<AssistantMessageEvent>, contextWindow?: number, callerSignal?: AbortSignal, requestedModel?: string): AsyncGenerator<StreamChunk>;
-//# sourceMappingURL=stream.d.ts.map