dsh-github-copilot 0.4.0-alpha.18

package/lib/remote.js

@@ -0,0 +1,162 @@
+import { z } from "zod";
+//#region lib/types/remote.js
+/**
+* Client-safe Remote contribution for the plugin-owned authorization bridge.
+*/
+const direct = { kind: "direct" };
+const GITHUB_COPILOT_AUTHORIZATION_VIEW_TYPE_SYMBOL = "dsh-github-copilot#GitHubCopilotAuthorizationView";
+const GitHubCopilotAuthorizationViewSchema = z.object({
+	phase: z.enum([
+		"signed-out",
+		"authorizing",
+		"signed-in",
+		"error"
+	]),
+	configured: z.boolean(),
+	writable: z.boolean(),
+	inFlight: z.boolean(),
+	notices: z.array(z.object({
+		message: z.string(),
+		url: z.string().optional(),
+		code: z.string().optional()
+	}).strict()),
+	catalog: z.object({
+		state: z.enum([
+			"current",
+			"partially-outdated",
+			"outdated"
+		]),
+		accountModelCount: z.number().int().nonnegative(),
+		supportedModelCount: z.number().int().nonnegative(),
+		unknownModelIds: z.array(z.string()),
+		temporarilyUnavailableModelIds: z.array(z.string()).optional(),
+		previewModelIds: z.array(z.string()).optional()
+	}).strict().optional(),
+	accountModels: z.object({
+		state: z.enum([
+			"idle",
+			"loading",
+			"ready",
+			"stale",
+			"error",
+			"disposed",
+			"unconfigured",
+			"unavailable"
+		]),
+		models: z.array(z.object({
+			id: z.string(),
+			name: z.string(),
+			api: z.string()
+		}).strict()).max(512),
+		rejected: z.array(z.object({
+			id: z.string().optional(),
+			code: z.string()
+		}).strict()).max(1024),
+		warnings: z.array(z.object({
+			id: z.string(),
+			code: z.string()
+		}).strict()).max(1024).optional(),
+		discoveredAt: z.number().int().nonnegative().optional(),
+		error: z.string().optional()
+	}).strict().optional(),
+	route: z.object({
+		state: z.enum([
+			"ready",
+			"needs-repair",
+			"not-configured",
+			"conflict",
+			"error"
+		]),
+		diagnosticCode: z.enum([
+			"ROUTE_READ_FAILED",
+			"RECONCILIATION_FAILED",
+			"ROUTE_CONFLICT"
+		]).optional()
+	}).strict().optional(),
+	error: z.string().optional()
+}).strict();
+const result = {
+	mode: "strict",
+	typeSymbol: GITHUB_COPILOT_AUTHORIZATION_VIEW_TYPE_SYMBOL,
+	schema: GitHubCopilotAuthorizationViewSchema
+};
+const GITHUB_COPILOT_MIGRATION_STATUS_TYPE_SYMBOL = "dsh-github-copilot#GitHubCopilotMigrationStatus";
+const selectionSchema = z.object({
+	provider: z.string().min(1).max(512),
+	model: z.string().min(1).max(512),
+	reasoningEffort: z.string().min(1).max(512).optional()
+}).strict();
+/** Independent Ops result: strict at every object level; no account or private Session data. */
+const GitHubCopilotMigrationStatusSchema = z.object({
+	plugin: z.object({
+		name: z.literal("dsh-github-copilot"),
+		version: z.string().min(1).max(512)
+	}).strict(),
+	protocolVersion: z.literal(1),
+	historyScope: z.literal("live-agents-only"),
+	observedAt: z.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER),
+	capabilities: z.object({
+		agentsList: z.boolean(),
+		sessionProjections: z.boolean(),
+		settingsCas: z.boolean(),
+		providerRegistry: z.boolean(),
+		defaultSelection: z.boolean()
+	}).strict(),
+	complete: z.object({
+		sessions: z.boolean(),
+		defaultSelection: z.boolean(),
+		routes: z.boolean()
+	}).strict(),
+	defaultSelection: selectionSchema.nullable(),
+	sessions: z.array(z.object({
+		id: z.string().min(1).max(512),
+		status: z.enum(["idle", "running"]),
+		effectiveSelection: selectionSchema.nullable(),
+		selectionSource: z.enum([
+			"pending",
+			"request-header",
+			"default",
+			"unknown"
+		]),
+		activeRequestSelection: selectionSchema.nullable()
+	}).strict()).max(1024),
+	routes: z.object({
+		nativeConfigured: z.boolean().nullable(),
+		nativeRegistered: z.boolean().nullable(),
+		managedRegistered: z.boolean().nullable()
+	}).strict()
+}).strict();
+const contribution = {
+	package: "dsh-github-copilot",
+	descriptors: [...[
+		"status",
+		"reconcile",
+		"discoverModels",
+		"ensureModels",
+		"start",
+		"cancel",
+		"signOut"
+	].map((method) => ({
+		id: `dsh-github-copilot:githubCopilot.${method}`,
+		service: "githubCopilotAuthorization",
+		namespace: "githubCopilot",
+		method,
+		invocation: direct,
+		parameters: [],
+		result
+	})), {
+		id: "dsh-github-copilot:githubCopilot.migrationStatus",
+		service: "githubCopilotAuthorization",
+		namespace: "githubCopilot",
+		method: "migrationStatus",
+		invocation: direct,
+		parameters: [],
+		result: {
+			mode: "strict",
+			typeSymbol: GITHUB_COPILOT_MIGRATION_STATUS_TYPE_SYMBOL,
+			schema: GitHubCopilotMigrationStatusSchema
+		}
+	}]
+};
+//#endregion
+export { GITHUB_COPILOT_AUTHORIZATION_VIEW_TYPE_SYMBOL, GITHUB_COPILOT_MIGRATION_STATUS_TYPE_SYMBOL, GitHubCopilotAuthorizationViewSchema, GitHubCopilotMigrationStatusSchema, contribution as default };

package/lib/routed-web.js

@@ -0,0 +1,80 @@
+import { C as currentSearchInitiator, T as isPluginPreviewProvider, t as isCopilotSearchSelection, w as currentSearchSelection } from "./search-routing-pFLux0W7.js";
+import { WebError, WebRuntime } from "@deepseek-ai/dsh-web";
+//#region lib/types/routed-web.js
+/**
+* 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.
+*/
+var CopilotRoutedWeb = class extends WebRuntime {
+	static inject = ["githubCopilotOriginalWeb"];
+	bounded;
+	lifetime = new AbortController();
+	pending = /* @__PURE__ */ new Set();
+	mirroredSearchProviders = /* @__PURE__ */ new Map();
+	constructor(ctx, config = {}) {
+		super(ctx, config);
+		this.bounded = new WebRuntime(ctx.isolate("web"), { searchProvider: "copilot-session-search" });
+		this.bounded.registerSearchProvider({
+			id: "copilot-session-search",
+			available: () => !this.lifetime.signal.aborted,
+			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));
+			}
+		});
+		ctx.effect(() => async () => {
+			this.lifetime.abort();
+			await Promise.allSettled(this.pending);
+			this.mirroredSearchProviders.clear();
+		});
+	}
+	disposedError() {
+		return new WebError("Copilot search service was disposed", "WEB_PROVIDER_UNAVAILABLE");
+	}
+	searchWithProvider(providerId, request, signal) {
+		const provider = this.mirroredSearchProviders.get(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);
+	}
+	registerSearchProvider(provider) {
+		if (this.lifetime.signal.aborted) throw this.disposedError();
+		const disposeOriginal = this.ctx.githubCopilotOriginalWeb.registerSearchProvider(provider);
+		const providers = this.mirroredSearchProviders;
+		const disposeMirror = this.ctx.effect(function* () {
+			providers.set(provider.id, provider);
+			yield () => {
+				if (providers.get(provider.id) === provider) providers.delete(provider.id);
+			};
+		}, "github-copilot.search-provider-mirror");
+		return () => {
+			disposeMirror();
+			disposeOriginal();
+		};
+	}
+	registerFetchProvider(provider) {
+		if (this.lifetime.signal.aborted) throw this.disposedError();
+		return this.ctx.githubCopilotOriginalWeb.registerFetchProvider(provider);
+	}
+	fetch(request, signal) {
+		if (this.lifetime.signal.aborted) return Promise.reject(this.disposedError());
+		return this.ctx.githubCopilotOriginalWeb.fetch(request, signal);
+	}
+	search(request, signal) {
+		if (this.lifetime.signal.aborted) return Promise.reject(this.disposedError());
+		const selection = currentSearchSelection(currentSearchInitiator(this.ctx));
+		const owned = selection?.provider === "github-copilot-preview" && isPluginPreviewProvider(this.ctx, selection.provider);
+		if (!isCopilotSearchSelection(selection, owned) && this.ctx.get("githubCopilotSearchRouter") === void 0) return this.ctx.githubCopilotOriginalWeb.search(request, signal);
+		const boundSignal = AbortSignal.any([...signal === void 0 ? [] : [signal], this.lifetime.signal]);
+		const operation = this.bounded.search(request, boundSignal);
+		this.pending.add(operation);
+		operation.then(() => this.pending.delete(operation), () => this.pending.delete(operation));
+		return operation;
+	}
+};
+//#endregion
+export { CopilotRoutedWeb as default };