dsh-github-copilot 0.4.0-alpha.21 → 0.4.0-alpha.23

package/lib/remote.js

@@ -32,7 +32,7 @@ const DualModelCreateSchema = z.object({
 	expectedRevision: revision
 }).strict();
 const DualModelCreateResultSchema = z.object({ sessionId: id }).strict();
-const contribution$1 = {
+const contribution$2 = {
 	package: "dsh-github-copilot",
 	descriptors: [
 		{
@@ -94,6 +94,25 @@ const contribution$1 = {
 		}
 	]
 };
+const contribution$1 = {
+	package: "dsh-github-copilot",
+	descriptors: [{
+		id: "dsh-github-copilot:githubCopilotSearchRouting.providers",
+		namespace: "githubCopilotSearchRouting",
+		service: "githubCopilotSearchRouting",
+		method: "providers",
+		invocation: { kind: "direct" },
+		parameters: [],
+		result: {
+			mode: "strict",
+			typeSymbol: "dsh-github-copilot#SearchProviderCatalog",
+			schema: z.object({
+				supported: z.boolean(),
+				providers: z.array(z.object({ id: z.string().min(1).max(512) }).strict()).max(512)
+			}).strict()
+		}
+	}]
+};
 //#endregion
 //#region lib/types/remote.js
 /**
@@ -255,6 +274,7 @@ const contribution = {
 				schema: GitHubCopilotMigrationStatusSchema
 			}
 		},
+		...contribution$2.descriptors,
 		...contribution$1.descriptors
 	]
 };

package/lib/routed-web.js

@@ -16,6 +16,7 @@ var CopilotRoutedWeb = class extends WebRuntime {
 	mirroredSearchProviders = /* @__PURE__ */ new Map();
 	constructor(ctx, config = {}) {
 		super(ctx, config);
+		ctx.provide("githubCopilotSearchCatalog", { list: () => [...this.mirroredSearchProviders.keys()] });
 		this.bounded = new WebRuntime(ctx.isolate("web"), { searchProvider: "copilot-session-search" });
 		this.bounded.registerSearchProvider({
 			id: "copilot-session-search",
@@ -23,7 +24,7 @@ var CopilotRoutedWeb = class extends WebRuntime {
 			search: (request, signal) => {
 				const router = ctx.get("githubCopilotSearchRouter");
 				if (router === void 0) throw new WebError("Copilot session search routing is not ready", "WEB_PROVIDER_UNAVAILABLE");
-				return router.search(request, signal, (query, querySignal) => ctx.githubCopilotOriginalWeb.search(query, querySignal), (providerId, query, querySignal) => this.searchWithProvider(providerId, query, querySignal));
+				return router.search(request, signal, (query, querySignal) => ctx.githubCopilotOriginalWeb.search(query, querySignal), (providerId, query, querySignal) => this.searchWithProvider(providerId, query, querySignal), (providerId) => this.captureSearchProvider(providerId));
 			}
 		});
 		ctx.effect(() => async () => {
@@ -36,19 +37,57 @@ var CopilotRoutedWeb = class extends WebRuntime {
 		return new WebError("Copilot search service was disposed", "WEB_PROVIDER_UNAVAILABLE");
 	}
 	searchWithProvider(providerId, request, signal) {
-		const provider = this.mirroredSearchProviders.get(providerId);
+		const provider = this.captureSearchProvider(providerId);
 		if (provider === void 0) return Promise.reject(new WebError(`configured web provider "${providerId}" is not registered`, "WEB_PROVIDER_CONFIGURED_MISSING"));
-		if (!provider.available()) return Promise.reject(new WebError(`configured web provider "${providerId}" is registered but unavailable`, "WEB_PROVIDER_CONFIGURED_UNAVAILABLE"));
 		return provider.search(request, signal);
 	}
+	captureSearchProvider(providerId) {
+		const entry = this.mirroredSearchProviders.get(providerId);
+		if (entry === void 0) return void 0;
+		const signal = AbortSignal.any([this.lifetime.signal, entry.cancellation.signal]);
+		const current = () => !signal.aborted && this.mirroredSearchProviders.get(providerId) === entry;
+		const available = entry.provider.available.bind(entry.provider);
+		const search = entry.provider.search.bind(entry.provider);
+		return {
+			id: providerId,
+			signal,
+			current,
+			owns: (provider) => current() && entry.provider === provider,
+			search: async (request, callerSignal) => {
+				const boundSignal = AbortSignal.any([signal, ...callerSignal === void 0 ? [] : [callerSignal]]);
+				const assertCurrent = () => {
+					if (boundSignal.aborted) throw new WebError("web search aborted", "WEB_ABORTED");
+					if (!current()) throw new WebError("web search provider registration invalidated", "WEB_PROVIDER_UNAVAILABLE");
+				};
+				assertCurrent();
+				try {
+					const usable = available();
+					assertCurrent();
+					if (!usable) throw new WebError(`configured web provider "${providerId}" is registered but unavailable`, "WEB_PROVIDER_CONFIGURED_UNAVAILABLE");
+					const result = await search(request, boundSignal);
+					assertCurrent();
+					return result;
+				} catch (error) {
+					assertCurrent();
+					throw error;
+				}
+			}
+		};
+	}
 	registerSearchProvider(provider) {
 		if (this.lifetime.signal.aborted) throw this.disposedError();
 		const disposeOriginal = this.ctx.githubCopilotOriginalWeb.registerSearchProvider(provider);
 		const providers = this.mirroredSearchProviders;
+		const providerId = provider.id;
+		const entry = {
+			provider,
+			cancellation: new AbortController()
+		};
 		const disposeMirror = this.ctx.effect(function* () {
-			providers.set(provider.id, provider);
+			providers.set(providerId, entry);
 			yield () => {
-				if (providers.get(provider.id) === provider) providers.delete(provider.id);
+				entry.cancellation.abort();
+				if (providers.get(providerId) === entry) providers.delete(providerId);
 			};
 		}, "github-copilot.search-provider-mirror");
 		return () => {

package/lib/types/dual-model-host.d.ts

@@ -1,4 +1,5 @@
-import { Context, Service } from '@deepseek-ai/cordis';
+import { Context } from '@deepseek-ai/cordis';
+import { TypertRemoteService } from '@deepseek-ai/dsh-typert-protocol';
 import { z as json } from 'zod';
 import type { DualModelView, DualModelSaveRequest, DualModelCreateRequest, DualModelCreateResult } from './dual-model-types.ts';
 export declare const DUAL_MODEL_NAMESPACE = "github-copilot-dual-model";
@@ -91,7 +92,7 @@ declare module '@deepseek-ai/cordis' {
     }
 }
 /** Always mountable; missing optional APIs produce a safe unsupported view. */
-export default class GitHubCopilotDualModel extends Service {
+export default class GitHubCopilotDualModel extends TypertRemoteService {
     private readonly owner;
     private readonly lifetime;
     private readonly creates;

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

@@ -5,9 +5,20 @@ import type { WebRuntimeConfig, WebSearchRequest, WebSearchResult, WebSearchProv
 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>;
+/** Captured facade registration; no provider implementation object crosses the Client boundary. */
+export interface CapturedSearchProvider {
+    readonly id: string;
+    readonly signal: AbortSignal;
+    current(): boolean;
+    /** Identity proof for a router-owned provider, never an inference from its id. */
+    owns(provider: WebSearchProvider): boolean;
+    search(request: WebSearchRequest, signal?: AbortSignal): Promise<WebSearchResult>;
+}
+/** Resolve one registered id synchronously before the routing operation starts awaiting. */
+export type CaptureSearchProvider = (providerId: string) => CapturedSearchProvider | undefined;
 /** 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>;
+    search(request: WebSearchRequest, signal: AbortSignal | undefined, delegate: NativeSearch, selectProvider?: ProviderSearch, captureSearchProvider?: CaptureSearchProvider): Promise<WebSearchResult>;
 }
 declare module '@deepseek-ai/cordis' {
     interface Context {
@@ -30,6 +41,7 @@ export default class CopilotRoutedWeb extends WebRuntime {
     constructor(ctx: Context, config?: WebRuntimeConfig);
     private disposedError;
     private searchWithProvider;
+    private captureSearchProvider;
     registerSearchProvider(provider: WebSearchProvider): () => void;
     registerFetchProvider(provider: WebFetchProvider): () => void;
     fetch(request: WebFetchRequest, signal?: AbortSignal): Promise<WebFetchResult>;

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

@@ -0,0 +1,19 @@
+/** Read-only search catalog bridge; no credentials, availability probes or writes. */
+import { Context } from '@deepseek-ai/cordis';
+import { TypertRemoteService } from '@deepseek-ai/dsh-typert-protocol';
+import type { SearchProviderCatalog } from './search-routing-remote.ts';
+export interface SearchProviderDirectory {
+    /** Fresh IDs from facade-owned registrations, not a process-wide registry. */
+    list(): readonly string[];
+}
+declare module '@deepseek-ai/cordis' {
+    interface Context {
+        githubCopilotSearchCatalog: SearchProviderDirectory;
+        githubCopilotSearchRouting: SearchRoutingController;
+    }
+}
+export default class SearchRoutingController extends TypertRemoteService {
+    constructor(ctx: Context);
+    providers(): SearchProviderCatalog;
+}
+//# sourceMappingURL=search-routing-host.d.ts.map

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

@@ -0,0 +1,18 @@
+/** Shared Client-safe settings shape; provider credentials and models remain provider-owned. */
+export interface WebSearchRoutingConfig {
+    /** Auto follows the initiating Chat provider; a concrete id pins the primary, and none disables search. */
+    searchProvider?: string;
+    /** Legacy primary selection; used only when searchProvider has not been explicitly saved. */
+    searchMode?: 'auto' | 'fixed';
+    /** Final fallback provider id, or none; legacy fixed mode also uses this id as its primary. */
+    defaultSearchProvider?: string;
+}
+/** Operation-local normalized policy; reading legacy settings never migrates them on disk. */
+export interface NormalizedWebSearchRouting {
+    readonly primaryProvider: string;
+    readonly defaultProvider: string;
+    readonly legacy: boolean;
+}
+/** Resolve old and new settings without guessing registered providers or dropping unknown ids. */
+export declare function normalizeWebSearchRouting(config: WebSearchRoutingConfig): NormalizedWebSearchRouting;
+//# sourceMappingURL=search-routing-policy.d.ts.map

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

@@ -0,0 +1,20 @@
+/** Client-safe catalog of search registrations observed by the routed facade. */
+import type { RemoteResult, TypertRemoteContribution } from '@deepseek-ai/dsh-typert-protocol';
+import { z } from 'zod';
+export declare const SearchProviderCatalogSchema: z.ZodObject<{
+    supported: z.ZodBoolean;
+    providers: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type SearchProviderCatalog = z.infer<typeof SearchProviderCatalogSchema>;
+declare module '@deepseek-ai/dsh-typert-protocol' {
+    interface TypertRemoteNamespaceMap {
+        githubCopilotSearchRouting: {
+            providers(): Promise<RemoteResult<SearchProviderCatalog>>;
+        };
+    }
+}
+declare const contribution: TypertRemoteContribution;
+export default contribution;
+//# sourceMappingURL=search-routing-remote.d.ts.map

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

@@ -0,0 +1,22 @@
+import type { WebSearchRequest, WebSearchResult } from '@deepseek-ai/dsh-web';
+/** An already selected, operation-owned search entry; availability remains its owner's responsibility. */
+export interface SearchToolProvider {
+    readonly id: string;
+    search(request: WebSearchRequest, signal?: AbortSignal): Promise<WebSearchResult>;
+}
+/** Captured policy for one primary attempt and at most one distinct final fallback. */
+export interface SearchToolRoutingDependencies {
+    readonly primary?: SearchToolProvider | undefined;
+    readonly fallback?: SearchToolProvider | undefined;
+    /** False, or a thrown error, revokes this operation without permitting fallback. */
+    readonly canContinue: () => boolean;
+    /** Legacy failure-spending control; does not prevent fallback when no primary was resolved. */
+    readonly allowFailureFallback?: boolean;
+}
+/**
+ * Execute a captured primary and optional final fallback without registry or credential access.
+ * The caller resolves Auto, handles disabled policy, proves registrations and supplies lifetime guards.
+ * Generic providers must honor the signal; this helper cannot inspect their internal auth/HTTP boundary.
+ */
+export declare function routeSearchTools(request: WebSearchRequest, signal: AbortSignal | undefined, deps: SearchToolRoutingDependencies): Promise<WebSearchResult>;
+//# sourceMappingURL=search-tool-routing.d.ts.map

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

@@ -3,8 +3,9 @@ import type { ReactElement } from 'react';
 interface SearchRoutingCardProps {
     readonly settings: ClientContext['remote']['settings'];
     readonly copilot: ClientContext['remote']['githubCopilot'];
+    readonly routing: ClientContext['remote']['githubCopilotSearchRouting'];
 }
-/** Models-page card for plugin-owned cross-provider search routing. */
+/** Provider-level primary and final fallback; model choice stays with each provider. */
 export declare function WebSearchRoutingCard(props: SearchRoutingCardProps): ReactElement;
 export {};
 //# sourceMappingURL=web-search-routing-card.d.ts.map

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

@@ -1,16 +1,12 @@
 import z from '@deepseek-ai/schemastery';
 import type { SettingsNamespace } from '@deepseek-ai/dsh-settings';
+import type { WebSearchRoutingConfig } from './search-routing-policy.ts';
+export { normalizeWebSearchRouting } from './search-routing-policy.ts';
+export type { WebSearchRoutingConfig, NormalizedWebSearchRouting } from './search-routing-policy.ts';
 /** Plugin-owned settings namespace for cross-provider web-search routing. */
 export declare const WEB_SEARCH_ROUTING_SETTINGS_NAMESPACE: SettingsNamespace;
 /** Sentinel that disables the default/fixed search backend. */
 export declare const NO_DEFAULT_SEARCH_PROVIDER = "none";
-/** Cross-provider policy applied by this plugin's routed web facade. */
-export interface WebSearchRoutingConfig {
-    /** Auto prefers the initiating model's native search; fixed always uses the configured provider. */
-    searchMode?: 'auto' | 'fixed';
-    /** Registered search-provider id used by fixed mode and as auto mode's fallback. */
-    defaultSearchProvider?: string;
-}
 /** User-facing routing settings; provider-specific credentials and models remain provider-owned. */
 export declare const WebSearchRoutingConfigSchema: z<WebSearchRoutingConfig>;
 //# sourceMappingURL=web-search-routing-config.d.ts.map

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "dsh-github-copilot",
   "description": "DSH companion for GitHub Copilot sign-in, account-aware model profiles, tool compatibility, and provider-hosted search.",
-  "version": "0.4.0-alpha.21",
+  "version": "0.4.0-alpha.23",
   "publishConfig": {
     "access": "public",
     "registry": "https://registry.npmjs.org/",
@@ -94,8 +94,7 @@
     "@deepseek-ai/dsh-typert-protocol": "0.1.1-rc.2 || 0.1.2-rc.1 || 0.1.3-alpha.1 || 0.1.5-alpha.1 || 0.1.5-alpha.2 || 0.1.5-rc.1 || 0.1.5-rc.2 || 0.1.6-alpha.1",
     "@deepseek-ai/dsh-web": "0.1.1-rc.2 || 0.1.2-rc.1 || 0.1.3-alpha.1 || 0.1.5-alpha.1 || 0.1.5-alpha.2 || 0.1.5-rc.1 || 0.1.5-rc.2 || 0.1.6-alpha.1",
     "@deepseek-ai/dsh-web-search-deepseek": "0.1.1-rc.2 || 0.1.2-rc.1 || 0.1.3-alpha.1 || 0.1.5-alpha.1 || 0.1.5-alpha.2 || 0.1.5-rc.1 || 0.1.5-rc.2 || 0.1.6-alpha.1",
-    "@deepseek-ai/schemastery": "^3.18.2",
-    "react": "^18.2.0"
+    "@deepseek-ai/schemastery": "^3.18.2"
   },
   "peerDependenciesMeta": {
     "@deepseek-ai/dsh-web-search-deepseek": {
@@ -172,6 +171,9 @@
       "patch": "./cordis.patch.yml"
     },
     "client": {
+      "external": [
+        "react"
+      ],
       "inject": [
         "@deepseek-ai/dsh-api-remotes",
         "@deepseek-ai/dsh-client-ui-settings-models"