dsh-github-copilot 0.4.0-alpha.18

package/lib/types/remote.d.ts

@@ -0,0 +1,151 @@
+/**
+ * Client-safe Remote contribution for the plugin-owned authorization bridge.
+ */
+import type { RemoteResult, TypertRemoteContribution } from '@deepseek-ai/dsh-typert-protocol';
+import { z } from 'zod';
+import type { GitHubCopilotAuthorizationView } from './authorization-controller.ts';
+import type { GitHubCopilotMigrationStatus } from './migration-status.ts';
+declare module '@deepseek-ai/dsh-typert-protocol' {
+    interface TypertRemoteNamespaceMap {
+        githubCopilot: {
+            migrationStatus(): Promise<RemoteResult<GitHubCopilotMigrationStatus>>;
+            status(): Promise<RemoteResult<GitHubCopilotAuthorizationView>>;
+            reconcile(): Promise<RemoteResult<GitHubCopilotAuthorizationView>>;
+            discoverModels(): Promise<RemoteResult<GitHubCopilotAuthorizationView>>;
+            ensureModels(): Promise<RemoteResult<GitHubCopilotAuthorizationView>>;
+            start(): Promise<RemoteResult<GitHubCopilotAuthorizationView>>;
+            cancel(): Promise<RemoteResult<GitHubCopilotAuthorizationView>>;
+            signOut(): Promise<RemoteResult<GitHubCopilotAuthorizationView>>;
+        };
+    }
+}
+export declare const GITHUB_COPILOT_AUTHORIZATION_VIEW_TYPE_SYMBOL = "dsh-github-copilot#GitHubCopilotAuthorizationView";
+export declare const GitHubCopilotAuthorizationViewSchema: z.ZodObject<{
+    phase: z.ZodEnum<{
+        error: "error";
+        "signed-out": "signed-out";
+        authorizing: "authorizing";
+        "signed-in": "signed-in";
+    }>;
+    configured: z.ZodBoolean;
+    writable: z.ZodBoolean;
+    inFlight: z.ZodBoolean;
+    notices: z.ZodArray<z.ZodObject<{
+        message: z.ZodString;
+        url: z.ZodOptional<z.ZodString>;
+        code: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    catalog: z.ZodOptional<z.ZodObject<{
+        state: z.ZodEnum<{
+            current: "current";
+            "partially-outdated": "partially-outdated";
+            outdated: "outdated";
+        }>;
+        accountModelCount: z.ZodNumber;
+        supportedModelCount: z.ZodNumber;
+        unknownModelIds: z.ZodArray<z.ZodString>;
+        temporarilyUnavailableModelIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        previewModelIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>>;
+    accountModels: z.ZodOptional<z.ZodObject<{
+        state: z.ZodEnum<{
+            error: "error";
+            idle: "idle";
+            loading: "loading";
+            ready: "ready";
+            stale: "stale";
+            disposed: "disposed";
+            unconfigured: "unconfigured";
+            unavailable: "unavailable";
+        }>;
+        models: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodString;
+            api: z.ZodString;
+        }, z.core.$strict>>;
+        rejected: z.ZodArray<z.ZodObject<{
+            id: z.ZodOptional<z.ZodString>;
+            code: z.ZodString;
+        }, z.core.$strict>>;
+        warnings: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            code: z.ZodString;
+        }, z.core.$strict>>>;
+        discoveredAt: z.ZodOptional<z.ZodNumber>;
+        error: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    route: z.ZodOptional<z.ZodObject<{
+        state: z.ZodEnum<{
+            error: "error";
+            ready: "ready";
+            "needs-repair": "needs-repair";
+            "not-configured": "not-configured";
+            conflict: "conflict";
+        }>;
+        diagnosticCode: z.ZodOptional<z.ZodEnum<{
+            ROUTE_READ_FAILED: "ROUTE_READ_FAILED";
+            RECONCILIATION_FAILED: "RECONCILIATION_FAILED";
+            ROUTE_CONFLICT: "ROUTE_CONFLICT";
+        }>>;
+    }, z.core.$strict>>;
+    error: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export declare const GITHUB_COPILOT_MIGRATION_STATUS_TYPE_SYMBOL = "dsh-github-copilot#GitHubCopilotMigrationStatus";
+/** Independent Ops result: strict at every object level; no account or private Session data. */
+export declare const GitHubCopilotMigrationStatusSchema: z.ZodObject<{
+    plugin: z.ZodObject<{
+        name: z.ZodLiteral<"dsh-github-copilot">;
+        version: z.ZodString;
+    }, z.core.$strict>;
+    protocolVersion: z.ZodLiteral<1>;
+    historyScope: z.ZodLiteral<"live-agents-only">;
+    observedAt: z.ZodNumber;
+    capabilities: z.ZodObject<{
+        agentsList: z.ZodBoolean;
+        sessionProjections: z.ZodBoolean;
+        settingsCas: z.ZodBoolean;
+        providerRegistry: z.ZodBoolean;
+        defaultSelection: z.ZodBoolean;
+    }, z.core.$strict>;
+    complete: z.ZodObject<{
+        sessions: z.ZodBoolean;
+        defaultSelection: z.ZodBoolean;
+        routes: z.ZodBoolean;
+    }, z.core.$strict>;
+    defaultSelection: z.ZodNullable<z.ZodObject<{
+        provider: z.ZodString;
+        model: z.ZodString;
+        reasoningEffort: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    sessions: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        status: z.ZodEnum<{
+            idle: "idle";
+            running: "running";
+        }>;
+        effectiveSelection: z.ZodNullable<z.ZodObject<{
+            provider: z.ZodString;
+            model: z.ZodString;
+            reasoningEffort: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+        selectionSource: z.ZodEnum<{
+            default: "default";
+            pending: "pending";
+            "request-header": "request-header";
+            unknown: "unknown";
+        }>;
+        activeRequestSelection: z.ZodNullable<z.ZodObject<{
+            provider: z.ZodString;
+            model: z.ZodString;
+            reasoningEffort: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    routes: z.ZodObject<{
+        nativeConfigured: z.ZodNullable<z.ZodBoolean>;
+        nativeRegistered: z.ZodNullable<z.ZodBoolean>;
+        managedRegistered: z.ZodNullable<z.ZodBoolean>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+declare const contribution: TypertRemoteContribution;
+export default contribution;
+//# sourceMappingURL=remote.d.ts.map

package/lib/types/responses-reasoning-text.d.ts

@@ -0,0 +1,24 @@
+/** Public Responses reasoning text only; encrypted replay payloads are never read. */
+type Family = 'summary' | 'raw';
+export declare function responseIndex(value: unknown): number | undefined;
+/**
+ * Append-only public text for one output item. Snapshots complete streamed
+ * prefixes rather than repeating them. If both public representations occur,
+ * stream the first and retain the other until item end so an identical mirror
+ * can be omitted without dropping a distinct public summary.
+ */
+export declare class ResponsesReasoningText {
+    private family;
+    private readonly parts;
+    private emitted;
+    private finished;
+    get text(): string;
+    private render;
+    update(family: Family, index: unknown, value: unknown, done: boolean): string;
+    /** Only recognized public text fields are examined; no copying of the item. */
+    snapshot(item: unknown): string;
+    /** Flush a distinct secondary representation, including on failure/abort. */
+    finish(): string;
+}
+export {};
+//# sourceMappingURL=responses-reasoning-text.d.ts.map

package/lib/types/responses-reasoning.d.ts

@@ -0,0 +1,7 @@
+import type { Context } from '@deepseek-ai/cordis';
+import type { GenerateOptions } from '@deepseek-ai/dsh-llm';
+import type { SearchPlanCandidate } from './plan.ts';
+import type { ResponsesReasoningOptions } from './serialize.ts';
+/** Resolve only the selected model's declared/native efforts, with the same precedence as Core. */
+export declare function resolveCopilotResponsesReasoning(ctx: Context, request: GenerateOptions, candidate: Pick<SearchPlanCandidate, 'protocol' | 'model'>): ResponsesReasoningOptions | undefined;
+//# sourceMappingURL=responses-reasoning.d.ts.map

package/lib/types/route-ownership.d.ts

@@ -0,0 +1,70 @@
+/** Journal provenance only; process identity is not namespace lifetime evidence. */
+export declare const ROUTE_OWNERSHIP_EPOCH: `${string}-${string}-${string}-${string}-${string}`;
+export type RouteMutation = {
+    readonly op: 'set';
+    readonly path: string[];
+    readonly value: unknown;
+} | {
+    readonly op: 'unset';
+    readonly path: string[];
+};
+export interface RouteSettings {
+    get(namespace: string): unknown;
+    describe(options?: {
+        redactSecrets?: boolean;
+    }): Array<{
+        ns: string;
+        revision: number;
+        user?: unknown;
+        base?: unknown;
+        secrets?: readonly {
+            path: readonly string[];
+            set: boolean;
+        }[];
+    }>;
+    mutate(namespace: string, operations: readonly RouteMutation[], expectedRevision?: number): Promise<void>;
+}
+export declare class TemporaryRouteConflictError extends Error {
+    readonly code: 'TEMPORARY_ROUTE_OWNERSHIP_CONFLICT' | 'TEMPORARY_ROUTE_LEGACY_CONFLICT' | 'TEMPORARY_ROUTE_INVALID_BACKUP';
+    constructor(code?: 'TEMPORARY_ROUTE_OWNERSHIP_CONFLICT' | 'TEMPORARY_ROUTE_LEGACY_CONFLICT' | 'TEMPORARY_ROUTE_INVALID_BACKUP');
+}
+export declare function object(value: unknown): Record<string, unknown> | undefined;
+export declare function profileAt(value: unknown): Record<string, unknown> | undefined;
+/** Bounded comparison; never stringify or copy unknown model extras or headers. */
+export declare function equalJson(a: unknown, b: unknown, depth?: number): boolean;
+interface Leaves {
+    readonly api?: string;
+    readonly models?: readonly Record<string, unknown>[];
+}
+export interface RouteBackup {
+    readonly version: 2;
+    readonly providerExisted: boolean;
+    readonly preimage: Leaves;
+    readonly postimage: Leaves;
+    readonly ownedHeaders: Readonly<Record<string, string>>;
+    readonly phase: 'overlay' | 'restoring';
+    readonly sourceRevision: number;
+    readonly sourceEpoch: string;
+    readonly target?: Leaves;
+    readonly removeProfile?: boolean;
+}
+export declare function leavesOf(profile: Record<string, unknown> | undefined): Leaves;
+export declare function encodeBackup(backup: RouteBackup): string;
+export declare function readBackup(value: unknown): RouteBackup | undefined;
+export declare function settingsSnapshot(settings: RouteSettings): {
+    current: Record<string, unknown> | undefined;
+    raw: Record<string, unknown> | undefined;
+    base: Record<string, unknown> | undefined;
+    hasSecrets: boolean;
+    hasOwnedSecrets: boolean;
+    routeRevision: number;
+    markerRevision: number;
+    backup: RouteBackup | undefined;
+};
+export declare function assertOwned(current: Record<string, unknown> | undefined, backup: RouteBackup): 'preimage' | 'postimage' | 'target';
+export declare function leafOperations(current: Record<string, unknown> | undefined, target: Leaves): RouteMutation[];
+export declare function ownedHeaderRemoval(current: Record<string, unknown> | undefined, backup: RouteBackup): RouteMutation[];
+/** Raw shape, not schema-resolved defaults, proves whole-profile ownership. */
+export declare function wholeProfileOwned(snapshot: ReturnType<typeof settingsSnapshot>, backup: RouteBackup): boolean;
+export {};
+//# sourceMappingURL=route-ownership.d.ts.map

package/lib/types/routed-web.d.ts

@@ -0,0 +1,38 @@
+import type { Context } from '@deepseek-ai/cordis';
+import { WebRuntime } from '@deepseek-ai/dsh-web';
+import type { WebRuntimeConfig, WebSearchRequest, WebSearchResult, WebSearchProvider, WebFetchProvider, WebFetchRequest, WebFetchResult } from '@deepseek-ai/dsh-web';
+/** Parent dispatch captured from the exact WebRuntime instance serving this call. */
+export type NativeSearch = (request: WebSearchRequest, signal?: AbortSignal) => Promise<WebSearchResult>;
+/** Exact-id dispatch over providers registered through the routed facade. */
+export type ProviderSearch = (providerId: string, request: WebSearchRequest, signal?: AbortSignal) => Promise<WebSearchResult>;
+/** Host-owned router; credentials and provider implementation objects stay inside the facade. */
+export interface GitHubCopilotSearchRouter {
+    search(request: WebSearchRequest, signal: AbortSignal | undefined, delegate: NativeSearch, selectProvider?: ProviderSearch): Promise<WebSearchResult>;
+}
+declare module '@deepseek-ai/cordis' {
+    interface Context {
+        githubCopilotSearchRouter: GitHubCopilotSearchRouter;
+    }
+}
+/**
+ * Plugin-owned WebRuntime facade. The bundle isolates, but does not reconfigure,
+ * the original official service. Normal search, fetch and registrations delegate
+ * through its public APIs. A second private official WebRuntime supplies the same
+ * validation/source cap for the Copilot branch. No Core prototypes or private
+ * registries are read or changed.
+ */
+export default class CopilotRoutedWeb extends WebRuntime {
+    static inject: string[];
+    private readonly bounded;
+    private readonly lifetime;
+    private readonly pending;
+    private readonly mirroredSearchProviders;
+    constructor(ctx: Context, config?: WebRuntimeConfig);
+    private disposedError;
+    private searchWithProvider;
+    registerSearchProvider(provider: WebSearchProvider): () => void;
+    registerFetchProvider(provider: WebFetchProvider): () => void;
+    fetch(request: WebFetchRequest, signal?: AbortSignal): Promise<WebFetchResult>;
+    search(request: WebSearchRequest, signal?: AbortSignal): Promise<WebSearchResult>;
+}
+//# sourceMappingURL=routed-web.d.ts.map

package/lib/types/search-backend.d.ts

@@ -0,0 +1,16 @@
+import { WebError } from '@deepseek-ai/dsh-web';
+/** Safe request-option leaves; never includes auth, URL path/query or opaque provider state. */
+export interface SearchBackend {
+    readonly provider: 'deepseek-official';
+    readonly origin: string;
+    readonly model: string;
+    readonly customEndpoint: boolean;
+}
+/** Bounded metadata included in the same query's successful or failed fallback notice. */
+export declare function describeSearchBackend(backend: SearchBackend): string;
+/** Known sanitized failure, distinct from arbitrary native provider exception messages. */
+export declare class DescribedSearchFallbackError extends WebError {
+    readonly backend: SearchBackend | undefined;
+    constructor(backend: SearchBackend | undefined, code?: WebError['code']);
+}
+//# sourceMappingURL=search-backend.d.ts.map

package/lib/types/search-routing.d.ts

@@ -0,0 +1,43 @@
+import type { WebSearchProvider, WebSearchRequest, WebSearchResult } from '@deepseek-ai/dsh-web';
+/** Explicit cross-provider spending policy; disabled unless the operator selects DeepSeek. */
+export type SearchFallback = 'none' | 'deepseek';
+/** Selection captured from the initiating request, never from a global default. */
+export interface SearchSelection {
+    readonly provider: string;
+    readonly model: string;
+}
+/** Public, non-secret provenance retained outside the canonical WebSearchResult. */
+export interface SearchRouting {
+    readonly requestedProvider: 'github-copilot-hosted';
+    readonly actualProvider: 'github-copilot-hosted' | 'deepseek-official';
+    readonly model: string;
+    readonly fallback: boolean;
+    readonly reason?: string;
+}
+/** Delegated results have no plugin provenance and retain their original object identity. */
+export interface RoutedSearchResult {
+    readonly result: WebSearchResult;
+    readonly routing?: SearchRouting;
+}
+/** Operation-local dependencies; providers must be owned instances, not private-registry lookups. */
+export interface SessionSearchDependencies {
+    readonly selection: SearchSelection | undefined;
+    readonly managedOwned: boolean;
+    readonly fallback: SearchFallback;
+    readonly copilot: WebSearchProvider;
+    readonly delegate: (request: WebSearchRequest, signal?: AbortSignal) => Promise<WebSearchResult>;
+    readonly resolveDeepSeek: () => Promise<WebSearchProvider>;
+    /** Recheck captured owner/account generation after every asynchronous boundary. */
+    readonly canContinue: () => boolean;
+}
+/** Match only the canonical route or a verified plugin-owned managed route. */
+export declare function isCopilotSearchSelection(selection: SearchSelection | undefined, managedOwned: boolean): boolean;
+/**
+ * Route one already-validated search using captured request identity.
+ * Non-Copilot calls delegate untouched. Copilot failures reach a known DeepSeek
+ * provider only under the explicit spending policy; cancellation and invalidated
+ * ownership never trigger fallback. Consumer validation, batching and deadlines
+ * remain the caller's responsibility, not this provider-selection function.
+ */
+export declare function routeSessionSearch(request: WebSearchRequest, signal: AbortSignal | undefined, deps: SessionSearchDependencies): Promise<RoutedSearchResult>;
+//# sourceMappingURL=search-routing.d.ts.map

package/lib/types/serialize.d.ts

@@ -0,0 +1,109 @@
+/**
+ * Text/tool serialization for the inline wire path, plus server-side web
+ * search injection. Reasoning and opaque replay histories remain Core-owned;
+ * this limited serializer refuses them instead of inventing Responses items.
+ * @module dsh-github-copilot/serialize
+ */
+import type { ContentBlock, GenerateOptions, Message, ToolSchema } from '@deepseek-ai/dsh-llm';
+import type { ResponsesWebSearchToolType } from './plan.ts';
+import type { InlineConfig } from './config.ts';
+/** Mapped only after the selected model's native capability checks succeed. */
+export interface ResponsesReasoningOptions {
+    readonly effort: string;
+    readonly summary: 'auto';
+}
+/** Keep Core-owned reasoning provenance and opaque replay state out of this serializer. */
+export declare function hasResponsesReplayContext(messages: readonly Message[]): boolean;
+/** Thrown for content whose projection must remain with Core. */
+export declare class UnsupportedContentError extends Error {
+    constructor(detail: string);
+}
+/**
+ * Stable short hash (FNV-1a variant) for synthesizing item ids.
+ * @param input - any string.
+ * @returns an 8-character base36 string.
+ */
+export declare function shortHash(input: string): string;
+/**
+ * Split a harness call id into the Responses `call_id`/`id` pair. Harness
+ * ids produced by the pi-ai adapter carry the `call_id|item_id` shape; ids
+ * from other origins get a synthesized item id.
+ * @param id - the harness tool-call id.
+ * @returns the call id and item id.
+ */
+export declare function splitCallId(id: string): {
+    callId: string;
+    itemId: string;
+};
+/**
+ * Concatenate the text blocks of a content array.
+ * @param content - the message content blocks.
+ * @returns the joined text.
+ */
+export declare function flattenText(content: readonly ContentBlock[]): string;
+/**
+ * Serialize one dsh message into Responses input items.
+ * @param message - the harness message.
+ * @returns the wire input items; may be empty for content-free messages.
+ * @throws UnsupportedContentError for image or Core-owned reasoning/replay content.
+ */
+export declare function serializeMessage(message: Message, pairedCallIds?: ReadonlySet<string>): unknown[];
+/**
+ * Return call ids that have both an assistant function call and a user tool
+ * result. Responses rejects either half when replayed alone, which can happen
+ * when a prior provider/tool failure ended the step before persistence wrote
+ * the matching result.
+ */
+export declare function pairedToolCallIds(messages: readonly Message[]): ReadonlySet<string>;
+/**
+ * Build the wire tools array: function tools (optionally stripped of the
+ * variants shadowed by server-side web tools) plus the server-side web
+ * search tool in the candidate's verified spelling.
+ * @param tools - the harness tool schemas.
+ * @param stripServerTools - whether to drop the shadowed function variants.
+ * @param webSearchToolType - the Responses spelling the probe verified.
+ * @returns the wire tools array.
+ */
+export declare function wireTools(tools: readonly ToolSchema[] | undefined, stripServerTools: boolean, webSearchToolType: ResponsesWebSearchToolType): unknown[];
+/**
+ * Build the complete Responses request body for one inline call.
+ * @param request - the harness request.
+ * @param cfg - the wire controls.
+ * @param model - the model the plan resolved (config override or the loop's
+ *   route model); the same model the capability probe verified.
+ * @param webSearchToolType - the Responses spelling the probe verified; the
+ *   wire must send exactly the spelling that passed.
+ * @returns the JSON body to POST.
+ */
+export declare function buildWireBody(request: GenerateOptions, cfg: Pick<InlineConfig, 'includeSources' | 'stripServerTools'>, model: string, webSearchToolType: ResponsesWebSearchToolType, reasoning?: ResponsesReasoningOptions): unknown;
+/**
+ * Build the Anthropic Messages wire tools array: function tools (optionally
+ * stripped of the `web_search` variant, which shadows the server-side tool)
+ * plus the server-side web search tool. Function tools carry no `type`.
+ * @param tools - the harness tool schemas.
+ * @param stripServerTools - whether to drop the shadowed function variants.
+ * @returns the wire tools array.
+ */
+export declare function anthropicWireTools(tools: readonly ToolSchema[] | undefined, stripServerTools: boolean): unknown[];
+/**
+ * Serialize one dsh message into Anthropic Messages content items.
+ * Assistant messages aggregate their blocks into one content array
+ * (reasoning without a usable signature becomes plain text).
+ * @param message - the harness message.
+ * @returns the Anthropic content items for this message.
+ * @throws UnsupportedContentError for image content.
+ */
+export declare function serializeAnthropicMessage(message: Message): unknown[];
+/**
+ * Build the complete Anthropic Messages request body for one inline call.
+ * The system prompt goes to the top-level `system` field (unlike the
+ * Responses wire, the Anthropic gateway keeps server-side web_search native
+ * with a top-level system).
+ * @param request - the harness request.
+ * @param cfg - the wire controls.
+ * @param model - the model the plan resolved (config override or the loop's
+ *   route model); the same model the capability probe verified.
+ * @returns the JSON body to POST.
+ */
+export declare function buildAnthropicWireBody(request: GenerateOptions, cfg: Pick<InlineConfig, 'stripServerTools'>, model: string): unknown;
+//# sourceMappingURL=serialize.d.ts.map

package/lib/types/sse.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Bounded SSE line parser for the inline wire path. Handles `event:` and
+ * `data:` fields, multi-line data, CRLF, comments, and trailing events
+ * without a final blank line; unknown fields are ignored and oversized
+ * individual events are rejected.
+ * @module dsh-github-copilot/sse
+ */
+/** Upper bound on one incomplete SSE event, in bytes. */
+export declare const MAX_SSE_EVENT_BYTES: number;
+/** Stable error raised when one incomplete SSE event exceeds its byte bound. */
+export declare class SseEventSizeError extends Error {
+    readonly limit: number;
+    constructor();
+}
+/** One parsed SSE event; `type` falls back to `message`. */
+export interface SseEvent {
+    readonly type: string;
+    readonly data: unknown;
+}
+/**
+ * Parse an SSE byte stream into typed events.
+ * @param body - the response body stream.
+ * @returns an async generator of parsed events.
+ * @throws on invalid JSON or when one event exceeds
+ * {@link MAX_SSE_EVENT_BYTES}.
+ */
+export declare function parseSse(body: ReadableStream<Uint8Array>): AsyncGenerator<SseEvent>;
+//# sourceMappingURL=sse.d.ts.map

package/lib/types/temporary-models.d.ts

@@ -0,0 +1,25 @@
+import type { Api } from '@earendil-works/pi-ai';
+import type { CopilotModelFacts } from './model-protocol.ts';
+/**
+ * Narrow compatibility metadata for account models that GitHub releases before
+ * the published pi-ai Copilot catalog catches up. Correct native protocol and
+ * capability metadata retire the correction; a matching ID alone does not.
+ */
+export interface TemporaryGitHubCopilotModel {
+    readonly id: string;
+    readonly name: string;
+    readonly api: Api;
+    readonly baseUrl: string;
+    readonly contextWindow: number;
+    readonly maxTokens: number;
+    readonly input: readonly ('text' | 'image')[];
+    readonly reasoningEfforts: Readonly<Record<string, string | null>>;
+    readonly headers: Readonly<Record<string, string>>;
+}
+/** Return a narrow correction until the native entry supplies the verified capabilities. */
+export declare function temporaryGitHubCopilotModel(modelId: string, installedModels: ReadonlyMap<string, CopilotModelFacts>, nativeAuthoritative?: boolean): TemporaryGitHubCopilotModel | undefined;
+/** Minimal llm-pi-ai settings entry for one temporary model. */
+export declare function temporaryGitHubCopilotModelProfile(model: TemporaryGitHubCopilotModel): Record<string, unknown>;
+/** Recognize metadata written by this overlay without matching user-owned extras. */
+export declare function temporaryGitHubCopilotModelFromProfile(value: Readonly<Record<string, unknown>>): TemporaryGitHubCopilotModel | undefined;
+//# sourceMappingURL=temporary-models.d.ts.map

package/lib/types/tool-schema-compat.d.ts

@@ -0,0 +1,17 @@
+import type { Context } from '@deepseek-ai/cordis';
+import type { ToolSchema } from '@deepseek-ai/dsh-llm';
+interface PromptAssemblyView {
+    readonly variables: Readonly<Record<string, string | undefined>>;
+    readonly tools: readonly ToolSchema[];
+}
+/**
+ * Copilot models repeatedly emit optional arguments even when runtime state
+ * makes them invalid. Remove unusable sandbox escalation fields and expose the
+ * multi-action Goal update as a discriminated union, so each action advertises
+ * only its legal fields. Other model providers retain the original schemas.
+ */
+export declare function filterCopilotToolAssembly<T extends PromptAssemblyView>(assembly: T, ownedPreview?: boolean): T;
+/** Install the provider-scoped filter after Agent model selection has run. */
+export declare function installCopilotToolSchemaCompatibility(ctx: Context): void;
+export {};
+//# sourceMappingURL=tool-schema-compat.d.ts.map

package/lib/types/traditional-search.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Traditional `ctx.web` search provider backed by a verified OpenAI Responses
+ * candidate. This is intentionally search-only: URL fetching remains owned by
+ * dedicated anonymous fetch providers.
+ * @module dsh-github-copilot/traditional-search
+ */
+import type { WebSearchProvider } from '@deepseek-ai/dsh-web';
+import type { InlineConfig } from './config.ts';
+import type { SearchPlan } from './plan.ts';
+import type { InlineHooks } from './wire.ts';
+/** Stable provider id selected through `web.searchProvider`. */
+export declare const GITHUB_COPILOT_HOSTED_SEARCH_PROVIDER_ID = "github-copilot-hosted";
+/** @deprecated Use {@link GITHUB_COPILOT_HOSTED_SEARCH_PROVIDER_ID}. */
+export declare const COPILOT_HOSTED_SEARCH_PROVIDER_ID = "github-copilot-hosted";
+/** Build the search-only provider registered with `ctx.web`. */
+export declare function createTraditionalSearchProvider(available: () => boolean, plan: (signal?: AbortSignal) => SearchPlan | Promise<SearchPlan>, hooks: InlineHooks, config: () => InlineConfig, unavailableMessage?: string): WebSearchProvider;
+//# sourceMappingURL=traditional-search.d.ts.map

package/lib/types/types.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Provider-private wire types for the two search-capable protocols this
+ * package speaks, restricted to the shapes the capability probe consumes:
+ * the OpenAI Responses API `web_search_call` evidence item and the
+ * Anthropic-compatible Messages API `web_search_tool_result` block. The
+ * probe's verdict is structural — a reply containing the evidence item means
+ * the endpoint executed native search inside the request.
+ * @module dsh-github-copilot/types
+ */
+/** A `web_search_call` output item: evidence that the server ran the tool. */
+export interface WebSearchCallItem {
+    readonly type: 'web_search_call';
+    readonly id?: string;
+    readonly status?: string;
+    readonly action?: {
+        readonly sources?: readonly ResponsesWebSearchSource[];
+    };
+}
+/** One Responses citation or search source. */
+export interface ResponsesWebSearchSource {
+    readonly url?: string;
+    readonly title?: string;
+    readonly snippet?: string;
+    readonly published_at?: string;
+}
+/** One annotation on generated output text. */
+export interface ResponsesAnnotation extends ResponsesWebSearchSource {
+    readonly type?: string;
+}
+/** Generated output text carrying optional URL citations. */
+export interface ResponsesOutputText {
+    readonly type: 'output_text';
+    readonly text?: string;
+    readonly annotations?: readonly ResponsesAnnotation[];
+}
+/** A generated message in a non-streamed Responses envelope. */
+export interface ResponsesMessageItem {
+    readonly type: 'message';
+    readonly content?: readonly ResponsesOutputText[];
+}
+/** Any output item consumed by the probe or traditional-search bridge. */
+export type ResponseOutputItem = WebSearchCallItem | ResponsesMessageItem | {
+    readonly type: string;
+};
+/** The non-streamed Responses envelope the probe parses. */
+export interface ResponsesResponse {
+    readonly id?: string;
+    readonly status?: string;
+    readonly output?: readonly ResponseOutputItem[];
+}
+/** A `web_search_result` item inside a `web_search_tool_result` block. */
+export interface WebSearchResultItem {
+    readonly type: string;
+    readonly url: string;
+}
+/** A `web_search_tool_result` content block: the citeable result shape. */
+export interface WebSearchToolResultBlock {
+    readonly type: 'web_search_tool_result';
+    readonly content?: readonly WebSearchResultItem[];
+}
+/** Any content block; only `web_search_tool_result` is consumed by the probe. */
+export type ContentBlock = WebSearchToolResultBlock | {
+    readonly type: string;
+};
+/** The Messages response envelope the probe parses. */
+export interface AnthropicResponse {
+    readonly content?: readonly ContentBlock[];
+}
+//# sourceMappingURL=types.d.ts.map

package/lib/types/usage.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Usage mapping for the inline wire path: Responses-API usage objects
+ * project onto the harness TokenUsage shape exactly like the pi-ai adapter
+ * (input minus cached, cache and reasoning split out as separate fields).
+ * @module dsh-github-copilot/usage
+ */
+import type { TokenUsage } from '@deepseek-ai/dsh-llm';
+/** The usage object carried by `response.completed` / `response.incomplete` (snake_case wire fields). */
+export interface WireUsage {
+    readonly input_tokens: number;
+    readonly output_tokens: number;
+    readonly total_tokens: number;
+    readonly input_tokens_details?: {
+        readonly cached_tokens?: number;
+    };
+    readonly output_tokens_details?: {
+        readonly reasoning_tokens?: number;
+    };
+}
+/**
+ * Map a wire usage object to the harness TokenUsage shape.
+ * @param usage - the provider usage object (snake_case wire fields).
+ * @returns the harness usage; cache and reasoning fields are omitted when absent.
+ */
+export declare function mapUsage(usage: WireUsage): TokenUsage;
+//# sourceMappingURL=usage.d.ts.map