cordisx 0.1.0-beta.2 → 0.1.0-beta.21

package/dist/bundled-plugins/@cordisx/plugin-cli-proxy-api/dist/types/icon.d.ts

@@ -0,0 +1,2 @@
+import type { CordisXPluginBrandIcon } from 'cordisx/contracts';
+export declare const CLI_PROXY_ICON: CordisXPluginBrandIcon;

package/dist/bundled-plugins/@cordisx/plugin-cli-proxy-api/dist/types/index.d.ts

@@ -0,0 +1,40 @@
+import type { Context, Fiber } from '@deepseek-ai/cordis';
+import Schema from '@deepseek-ai/schemastery';
+import { type CordisXLocalizedText } from 'cordisx/contracts';
+import '@cordisx/protocol/managed-service-ui/v1';
+export declare const name = "cli-proxy-api";
+export declare const inject: string[];
+export declare const icon: import("cordisx/contracts").CordisXPluginBrandIcon;
+export declare const manifest: {
+    $schema: "https://raw.githubusercontent.com/cordisx/cordisx-protocol/main/schemas/plugin-manifest.v1.schema.json";
+    schemaVersion: 1;
+    id: string;
+    name: string;
+    capabilities: {
+        name: "models.read" | "tasks.catalog.read" | "tasks.content.read" | "tasks.create" | "tasks.control" | "turns.submit" | "turns.control";
+        required: false;
+        reason: {
+            namespace: string;
+            key: string;
+            fallback: string;
+        };
+        scope: {};
+    }[];
+};
+export interface Config {
+    readonly providerIds: readonly string[];
+    readonly defaultCwd: string;
+}
+export declare const Config: Schema<Schemastery.ObjectS<{
+    providerIds: Schema<string[], string[]>;
+    defaultCwd: Schema<string, string>;
+}>, Schemastery.ObjectT<{
+    providerIds: Schema<string[], string[]>;
+    defaultCwd: Schema<string, string>;
+}>>;
+export declare const configApplies = "plugin-restart";
+export declare const presentation: {
+    name: CordisXLocalizedText<Readonly<Record<string, import("cordisx/contracts").CordisXMessageParam>>>;
+    description: CordisXLocalizedText<Readonly<Record<string, import("cordisx/contracts").CordisXMessageParam>>>;
+};
+export declare function apply(ctx: Context & Pick<Fiber, 'effect'>, config?: Config): void;

package/dist/bundled-plugins/@cordisx/plugin-cli-proxy-api/dist/types/manager-configuration.d.ts

@@ -0,0 +1,10 @@
+import type { Context } from '@deepseek-ai/cordis';
+export type PluginConfigurationOpenOutcome = {
+    readonly status: 'opened';
+} | {
+    readonly status: 'unavailable';
+} | {
+    readonly status: 'failed';
+    readonly message: string;
+};
+export declare function requestOwnPluginConfiguration(manager: Context['manager'] | undefined): Promise<PluginConfigurationOpenOutcome>;

package/dist/{src/plugins/cli-proxy-api/view.d.ts → bundled-plugins/@cordisx/plugin-cli-proxy-api/dist/types/provider-fleet-page.d.ts}

@@ -1,5 +1,6 @@
 import type { Context } from '@deepseek-ai/cordis';
-import type { CordisXReactPageProps } from '../../contracts.js';
+import type { CordisXReactPageProps } from 'cordisx/contracts';
+import './provider-fleet-page.css';
 interface Config {
     readonly providerIds: readonly string[];
     readonly defaultCwd: string;
@@ -38,4 +39,3 @@ interface Messages {
 }
 export declare function createProviderFleetPage(ctx: Context, config: Config): (props: CordisXReactPageProps<Messages>) => import("react").JSX.Element;
 export {};
-//# sourceMappingURL=view.d.ts.map

package/dist/bundled-plugins/@cordisx/plugin-cli-proxy-api/dist/types/service/adapter.d.ts

@@ -0,0 +1,32 @@
+import type { PlatformProviderAdapterV1, PlatformProviderFactoryConfigurationV2 } from '@cordisx/protocol/platform-provider/v2';
+import { BrokerClient } from './broker-client.js';
+export declare class CliProxyPlatformProviderAdapter implements PlatformProviderAdapterV1 {
+    readonly providerId: string;
+    readonly providerGeneration: string;
+    readonly configuration: PlatformProviderFactoryConfigurationV2;
+    private readonly signal;
+    readonly models: PlatformProviderAdapterV1['models'];
+    readonly sessions: PlatformProviderAdapterV1['sessions'];
+    readonly turns: PlatformProviderAdapterV1['turns'];
+    readonly approvals: PlatformProviderAdapterV1['approvals'];
+    private readonly client;
+    private readonly lifecycle;
+    private readonly sessionModels;
+    private disposed;
+    constructor(providerId: string, providerGeneration: string, configuration: PlatformProviderFactoryConfigurationV2, broker: ConstructorParameters<typeof BrokerClient>[0], signal: AbortSignal);
+    subscribeLifecycle: PlatformProviderAdapterV1['subscribeLifecycle'];
+    drain(): Promise<void>;
+    dispose(_reason: Parameters<PlatformProviderAdapterV1['dispose']>[0]): Promise<void>;
+    private unavailable;
+    private checkSession;
+    private checkModel;
+    private listModels;
+    private listSessions;
+    private readSession;
+    private createSession;
+    private controlSession;
+    private submitTurn;
+    private controlTurn;
+    private introduce;
+    private decideApproval;
+}

package/dist/bundled-plugins/@cordisx/plugin-cli-proxy-api/dist/types/service/bindings.d.ts

@@ -0,0 +1,3 @@
+import type { PlatformProviderBrokerBindingV1 } from '@cordisx/protocol/platform-provider/v1';
+export declare const VALUE_SCHEMA = "https://raw.githubusercontent.com/cordisx/cordisx-protocol/main/schemas/platform-provider-broker-value.v1.schema.json";
+export declare const BROKER_BINDINGS: readonly PlatformProviderBrokerBindingV1[];

package/dist/bundled-plugins/@cordisx/plugin-cli-proxy-api/dist/types/service/broker-client.d.ts

@@ -0,0 +1,9 @@
+import type { PlatformProviderBrokerV1, PlatformProviderJsonValue, PlatformProviderOperationV1, PlatformProviderResultV1 } from '@cordisx/protocol/platform-provider/v1';
+export declare class BrokerClient {
+    private readonly broker;
+    private sequence;
+    private readonly pending;
+    constructor(broker: PlatformProviderBrokerV1);
+    request(operation: PlatformProviderOperationV1, method: string, params: PlatformProviderJsonValue, signal?: AbortSignal): Promise<PlatformProviderResultV1<PlatformProviderJsonValue>>;
+    drain(): Promise<void>;
+}

package/dist/bundled-plugins/@cordisx/plugin-cli-proxy-api/dist/types/service/gateway-definition.d.ts

@@ -0,0 +1,149 @@
+export declare const CLI_PROXY_GATEWAY_MODEL_CATALOG_SCHEMA_V1: "https://raw.githubusercontent.com/cordisx/plugin-cli-proxy-api/main/schemas/cli-proxy-gateway-model-catalog.v1.schema.json";
+export declare const CLI_PROXY_GATEWAY_CODEX_UPSTREAMS_SCHEMA_V1: "https://raw.githubusercontent.com/cordisx/plugin-cli-proxy-api/main/schemas/cli-proxy-gateway-codex-upstream.v1.schema.json";
+export declare const CLI_PROXY_GATEWAY_OPENAI_UPSTREAMS_SCHEMA_V1: "https://raw.githubusercontent.com/cordisx/plugin-cli-proxy-api/main/schemas/cli-proxy-gateway-openai-upstream.v1.schema.json";
+export declare const CLI_PROXY_GATEWAY_SERVICE_ID = "gateway-runtime";
+export declare const CLI_PROXY_GATEWAY_MANAGEMENT_V1: Readonly<{
+    credentialSlot: "management-key";
+    path: "/v0/management";
+}>;
+export declare const cliProxyGatewayDefinition: {
+    readonly $schema: "https://raw.githubusercontent.com/cordisx/cordisx-protocol/main/schemas/managed-service-definition.v1.schema.json";
+    readonly contract: "cordisx.managed-service-definition/v1";
+    readonly schemaVersion: 1;
+    readonly serviceId: "gateway-runtime";
+    readonly launch: {
+        readonly executable: {
+            readonly kind: "named-command";
+            readonly command: "cli-proxy-api";
+        };
+        readonly arguments: readonly [];
+        readonly startupTimeoutMs: 15000;
+    };
+    readonly configuration: {
+        readonly template: "./config/cli-proxy-api.yaml";
+        readonly format: "yaml";
+        readonly delivery: {
+            readonly kind: "generation-private-process-file";
+            readonly argument: "--config";
+        };
+    };
+    readonly compositionOrigins: readonly [{
+        readonly id: "api";
+        readonly path: "/v1";
+    }];
+    readonly protectedBindings: readonly [{
+        readonly slot: "assigned-port";
+        readonly source: "host-assigned-loopback";
+        readonly target: "configuration";
+        readonly pointer: "/port";
+        readonly serialization: "port";
+    }, {
+        readonly slot: "gateway-key";
+        readonly source: "generated-local-key";
+        readonly target: "configuration";
+        readonly pointer: "/api-keys/0";
+    }, {
+        readonly slot: "management-key";
+        readonly source: "generated-local-key";
+        readonly target: "configuration";
+        readonly pointer: "/remote-management/secret-key";
+    }, {
+        readonly slot: "codex-upstreams";
+        readonly source: "composition";
+        readonly target: "configuration";
+        readonly pointer: "/codex-api-key";
+        readonly valueSchema: "https://raw.githubusercontent.com/cordisx/plugin-cli-proxy-api/main/schemas/cli-proxy-gateway-codex-upstream.v1.schema.json";
+    }, {
+        readonly slot: "openai-upstreams";
+        readonly source: "composition";
+        readonly target: "configuration";
+        readonly pointer: "/openai-compatibility";
+        readonly valueSchema: "https://raw.githubusercontent.com/cordisx/plugin-cli-proxy-api/main/schemas/cli-proxy-gateway-openai-upstream.v1.schema.json";
+    }];
+    readonly authentication: {
+        readonly mode: "none";
+    };
+    readonly httpAuthentication: {
+        readonly mode: "authorization-header";
+        readonly scheme: "Bearer";
+        readonly slot: "gateway-key";
+    };
+    readonly discovery: {
+        readonly kind: "host-assigned-loopback";
+    };
+    readonly operations: readonly [{
+        readonly operationId: "gateway.models.list";
+        readonly method: "GET";
+        readonly path: "/v1/models";
+        readonly responseSchema: "https://raw.githubusercontent.com/cordisx/plugin-cli-proxy-api/main/schemas/cli-proxy-gateway-model-catalog.v1.schema.json";
+        readonly timeoutMs: 5000;
+    }, {
+        readonly operationId: "gateway.management.accounts.list";
+        readonly method: "GET";
+        readonly path: "/v0/management/auth-files";
+        readonly responseSchema: "https://raw.githubusercontent.com/cordisx/plugin-cli-proxy-api/main/schemas/cli-proxy-management-auth-files.v1.schema.json";
+        readonly timeoutMs: 5000;
+        readonly httpAuthentication: {
+            readonly mode: "authorization-header";
+            readonly scheme: "Bearer";
+            readonly slot: "management-key";
+        };
+    }, {
+        readonly operationId: "gateway.management.accounts.toggle";
+        readonly method: "PATCH";
+        readonly path: "/v0/management/auth-files/status";
+        readonly requestSchema: "https://raw.githubusercontent.com/cordisx/plugin-cli-proxy-api/main/schemas/cli-proxy-management-operation.v1.schema.json";
+        readonly responseSchema: "https://raw.githubusercontent.com/cordisx/plugin-cli-proxy-api/main/schemas/cli-proxy-management-operation.v1.schema.json";
+        readonly timeoutMs: 5000;
+        readonly httpAuthentication: {
+            readonly mode: "authorization-header";
+            readonly scheme: "Bearer";
+            readonly slot: "management-key";
+        };
+    }, ...{
+        operationId: string;
+        method: "GET";
+        path: `/${string}`;
+        requestSchema: "https://raw.githubusercontent.com/cordisx/plugin-cli-proxy-api/main/schemas/cli-proxy-management-operation.v1.schema.json";
+        requestEncoding: "query";
+        responseSchema: "https://raw.githubusercontent.com/cordisx/plugin-cli-proxy-api/main/schemas/cli-proxy-management-operation.v1.schema.json";
+        timeoutMs: number;
+        httpAuthentication: {
+            mode: "authorization-header";
+            scheme: "Bearer";
+            slot: string;
+        };
+    }[], {
+        readonly operationId: "gateway.management.oauth.poll";
+        readonly method: "GET";
+        readonly path: "/v0/management/get-auth-status";
+        readonly requestSchema: "https://raw.githubusercontent.com/cordisx/plugin-cli-proxy-api/main/schemas/cli-proxy-management-operation.v1.schema.json";
+        readonly requestEncoding: "query";
+        readonly responseSchema: "https://raw.githubusercontent.com/cordisx/plugin-cli-proxy-api/main/schemas/cli-proxy-management-operation.v1.schema.json";
+        readonly timeoutMs: 5000;
+        readonly httpAuthentication: {
+            readonly mode: "authorization-header";
+            readonly scheme: "Bearer";
+            readonly slot: "management-key";
+        };
+    }, {
+        readonly operationId: "gateway.management.oauth.cancel";
+        readonly method: "DELETE";
+        readonly path: "/v0/management/oauth-session";
+        readonly requestSchema: "https://raw.githubusercontent.com/cordisx/plugin-cli-proxy-api/main/schemas/cli-proxy-management-operation.v1.schema.json";
+        readonly requestEncoding: "query";
+        readonly responseSchema: "https://raw.githubusercontent.com/cordisx/plugin-cli-proxy-api/main/schemas/cli-proxy-management-operation.v1.schema.json";
+        readonly timeoutMs: 5000;
+        readonly httpAuthentication: {
+            readonly mode: "authorization-header";
+            readonly scheme: "Bearer";
+            readonly slot: "management-key";
+        };
+    }];
+    readonly health: {
+        readonly path: "/v1/models";
+        readonly intervalMs: 250;
+        readonly timeoutMs: 1000;
+    };
+};
+export declare const cliProxyGatewayDefinitionRevision: `sha256:${string}`;

package/dist/bundled-plugins/@cordisx/plugin-cli-proxy-api/dist/types/service/gateway-ui.d.ts

@@ -0,0 +1,13 @@
+import type { ManagedServiceNodeUISourceV1 } from '@cordisx/protocol/managed-service-context/v1';
+import type { ManagedServiceIdentityV1 } from '@cordisx/protocol/managed-service-runtime/v1';
+import type { CliProxyUpstreamRegistryV1 } from './upstream-registry.js';
+interface GatewayUIState {
+    readonly pluginGeneration: string;
+    readonly registry: CliProxyUpstreamRegistryV1<ManagedServiceIdentityV1>;
+    readonly authorization: Map<string, boolean>;
+    activeRevision: number | undefined;
+    refreshGatewayModels(): Promise<void>;
+}
+export declare function bindGatewayUIState(state: GatewayUIState): () => void;
+export declare const managedServiceUI: ManagedServiceNodeUISourceV1;
+export {};

package/dist/bundled-plugins/@cordisx/plugin-cli-proxy-api/dist/types/service/gateway.d.ts

@@ -0,0 +1,17 @@
+import type { Fiber } from '@deepseek-ai/cordis';
+import type { ManagedServiceContextProviderV1 } from '@cordisx/protocol/managed-service-context/v1';
+import type { ManagedServiceApplyInputV1, ManagedServiceApplyV1, ManagedServiceIdentityV1, ManagedServiceServiceContextV1 } from '@cordisx/protocol/managed-service-runtime/v1';
+import { managedServiceUI } from './gateway-ui.js';
+import { CliProxyUpstreamRegistryV1 } from './upstream-registry.js';
+export * from './gateway-definition.js';
+export * from './upstream-registry.js';
+export declare const contextServices: readonly ManagedServiceContextProviderV1[];
+export { managedServiceUI };
+export declare const CLI_PROXY_NATIVE_PROVIDER_ID = "cli-proxy-api";
+export type CliProxyGatewayContextV1 = ManagedServiceServiceContextV1 & Pick<Fiber, 'effect'> & {
+    readonly cliProxyUpstreams: CliProxyUpstreamRegistryV1<ManagedServiceIdentityV1>;
+};
+export declare function activateCliProxyGateway(context: CliProxyGatewayContextV1, input: ManagedServiceApplyInputV1): Promise<void>;
+export declare const apply: ManagedServiceApplyV1 & {
+    inject: readonly ["managedServices", "cliProxyUpstreams"];
+};

package/dist/bundled-plugins/@cordisx/plugin-cli-proxy-api/dist/types/service/index.d.ts

@@ -0,0 +1,3 @@
+import type { PlatformProviderServiceApplyV2 } from '@cordisx/protocol/platform-provider/v2';
+export * from './upstream-registry.js';
+export declare const apply: PlatformProviderServiceApplyV2;

package/dist/bundled-plugins/@cordisx/plugin-cli-proxy-api/dist/types/service/lifecycle.d.ts

@@ -0,0 +1,28 @@
+import type { PlatformProviderBrokerV1, PlatformProviderLifecycleEventV1, PlatformProviderLifecycleSubscriptionV1, PlatformProviderResultV1, PlatformProviderSessionRefV1 } from '@cordisx/protocol/platform-provider/v1';
+export declare class LifecycleProjection {
+    private readonly providerId;
+    private readonly providerGeneration;
+    private readonly broker;
+    private readonly listeners;
+    private readonly approvals;
+    private readonly assistantText;
+    private readonly unsubscribeBroker;
+    private sequence;
+    private subscriptionSequence;
+    constructor(providerId: string, providerGeneration: string, broker: PlatformProviderBrokerV1);
+    subscribe(listener: (event: PlatformProviderLifecycleEventV1) => void | Promise<void>): PlatformProviderLifecycleSubscriptionV1;
+    decide(input: {
+        readonly session: PlatformProviderSessionRefV1;
+        readonly turnId: string;
+        readonly approvalId: string;
+        readonly decision: 'approved' | 'denied' | 'cancelled';
+    }): Promise<PlatformProviderResultV1<{
+        approvalId: string;
+        decision: 'approved' | 'denied' | 'cancelled';
+    }>>;
+    dispose(): Promise<void>;
+    private receive;
+    private publish;
+    private turnKey;
+    private approvalKey;
+}

package/dist/bundled-plugins/@cordisx/plugin-cli-proxy-api/dist/types/service/upstream-context.d.ts

@@ -0,0 +1,2 @@
+import type { ManagedServiceContextProviderV1 } from '@cordisx/protocol/managed-service-context/v1';
+export declare function createCliProxyUpstreamContextProviderV1(): ManagedServiceContextProviderV1;

package/dist/bundled-plugins/@cordisx/plugin-cli-proxy-api/dist/types/service/upstream-registry.d.ts

@@ -0,0 +1,178 @@
+export declare const CLI_PROXY_UPSTREAM_DESCRIPTOR_SCHEMA_V1 = "https://raw.githubusercontent.com/cordisx/plugin-cli-proxy-api/main/schemas/cli-proxy-upstream-descriptor.v1.schema.json";
+export declare const CLI_PROXY_UPSTREAM_DESCRIPTOR_CONTRACT_V1 = "cordisx.cli-proxy-upstream-descriptor/v1";
+export declare const CLI_PROXY_MODEL_CATALOG_CONTRACT_V1 = "cordisx.cli-proxy-model-catalog/v1";
+export declare const CLI_PROXY_GATEWAY_PLAN_CONTRACT_V1 = "cordisx.cli-proxy-gateway-plan/v1";
+export declare const CLI_PROXY_UPSTREAM_REGISTRY_SERVICE_V1 = "cliProxyUpstreams";
+export type CliProxyInputModalityV1 = 'text' | 'image' | 'audio';
+export type CliProxyWireApiV1 = 'responses' | 'chat-completions';
+export interface CliProxyModelRouteV1 {
+    readonly sourceModelId: string;
+    readonly modelId: string;
+    readonly displayName?: string;
+    readonly enabled: boolean;
+    readonly isDefault: boolean;
+    readonly inputModalities?: readonly CliProxyInputModalityV1[];
+}
+export interface CliProxyUpstreamDescriptorV1 {
+    readonly $schema: typeof CLI_PROXY_UPSTREAM_DESCRIPTOR_SCHEMA_V1;
+    readonly contract: typeof CLI_PROXY_UPSTREAM_DESCRIPTOR_CONTRACT_V1;
+    readonly schemaVersion: 1;
+    readonly revision: number;
+    readonly upstreamId: string;
+    readonly displayName: string;
+    readonly enabled: boolean;
+    readonly wireApi: CliProxyWireApiV1;
+    readonly prefix?: string;
+    readonly order: number;
+    readonly requestTimeoutMs: number;
+    readonly group: {
+        readonly groupId: string;
+        readonly displayName: string;
+        readonly order: number;
+    };
+    readonly models: readonly CliProxyModelRouteV1[];
+}
+export interface CliProxyUpstreamRegistrationV1<Source> {
+    readonly source: Source;
+    readonly descriptor: CliProxyUpstreamDescriptorV1;
+}
+export interface CliProxyUpstreamRevocationV1 {
+    readonly upstreamId: string;
+    readonly expectedRevision: number;
+}
+export interface CliProxyUpstreamProducerV1 {
+    readonly pluginId: string;
+    readonly pluginGeneration: string;
+}
+export type CliProxyRegistryDiagnosticCodeV1 = 'invalid-registration' | 'capacity-exceeded' | 'conflicting-source' | 'conflicting-producer' | 'conflicting-prefix' | 'conflicting-group' | 'conflicting-model-alias' | 'conflicting-default' | 'stale-revision' | 'stale-generation' | 'not-found';
+export interface CliProxyRegistryDiagnosticV1 {
+    readonly code: CliProxyRegistryDiagnosticCodeV1;
+    readonly field?: string;
+    readonly message: string;
+}
+export type CliProxyRegistryMutationResultV1 = {
+    readonly status: 'registered' | 'updated' | 'revoked';
+    readonly registryRevision: number;
+} | {
+    readonly status: 'unchanged';
+    readonly registryRevision: number;
+} | {
+    readonly status: 'rejected' | 'stale-generation';
+    readonly diagnostic: CliProxyRegistryDiagnosticV1;
+};
+export interface CliProxyUpstreamRegistrarV1<Source> {
+    readonly producer: CliProxyUpstreamProducerV1;
+    register(registration: CliProxyUpstreamRegistrationV1<Source>): CliProxyRegistryMutationResultV1;
+    revoke(input: CliProxyUpstreamRevocationV1): CliProxyRegistryMutationResultV1;
+    dispose(): CliProxyRegistryMutationResultV1;
+}
+export interface CliProxyUpstreamConsumerContextV1<Source> {
+    readonly cliProxyUpstreams: CliProxyUpstreamRegistrarV1<Source>;
+}
+export interface CliProxyModelCatalogModelV1 {
+    readonly modelId: string;
+    readonly gatewayModelId: string;
+    readonly displayName: string;
+    readonly sourceModelIds: readonly string[];
+    readonly isDefault: boolean;
+    readonly inputModalities: readonly CliProxyInputModalityV1[];
+}
+export interface CliProxyModelCatalogProviderV1 {
+    readonly providerId: string;
+    readonly displayName: string;
+    readonly prefix: string;
+    readonly wireApi: CliProxyWireApiV1;
+    readonly order: number;
+    readonly revision: number;
+    readonly groupId: string;
+    readonly requestTimeoutMs: number;
+    readonly models: readonly CliProxyModelCatalogModelV1[];
+}
+export interface CliProxyModelCatalogGroupV1 {
+    readonly groupId: string;
+    readonly displayName: string;
+    readonly order: number;
+    readonly providers: readonly CliProxyModelCatalogProviderV1[];
+}
+export interface CliProxyModelCatalogV1 {
+    readonly contract: typeof CLI_PROXY_MODEL_CATALOG_CONTRACT_V1;
+    readonly schemaVersion: 1;
+    readonly pluginGeneration: string;
+    readonly registryRevision: number;
+    readonly upstreamRevisions: Readonly<Record<string, number>>;
+    readonly groups: readonly CliProxyModelCatalogGroupV1[];
+    readonly catalogDigest: `sha256:${string}`;
+}
+export interface CliProxyGatewayCompositionV1<Source> {
+    readonly upstreamId: string;
+    readonly source: Source;
+    readonly origin: {
+        readonly slot: string;
+        readonly targetPointer: `/${string}`;
+    };
+    readonly authorization: {
+        readonly slot: string;
+        readonly targetPointer: `/${string}`;
+    };
+}
+export interface CliProxyGatewayPlanV1<Source> {
+    readonly contract: typeof CLI_PROXY_GATEWAY_PLAN_CONTRACT_V1;
+    readonly schemaVersion: 1;
+    readonly pluginGeneration: string;
+    readonly registryRevision: number;
+    readonly catalogDigest: `sha256:${string}`;
+    readonly configuration: {
+        readonly 'codex-api-key': readonly {
+            readonly 'api-key': null;
+            readonly prefix: string;
+            readonly 'base-url': null;
+            readonly 'request-retry': 0;
+            readonly models: readonly {
+                readonly name: string;
+                readonly alias: string;
+                readonly 'display-name': string;
+                readonly 'force-mapping': true;
+            }[];
+        }[];
+        readonly 'openai-compatibility': readonly {
+            readonly name: string;
+            readonly disabled: false;
+            readonly prefix: string;
+            readonly 'base-url': null;
+            readonly 'api-key-entries': readonly [{
+                readonly 'api-key': null;
+            }];
+            readonly 'request-retry': 0;
+            readonly models: readonly {
+                readonly name: string;
+                readonly alias: string;
+                readonly 'display-name': string;
+                readonly 'force-mapping': true;
+                readonly 'input-modalities'?: readonly CliProxyInputModalityV1[];
+            }[];
+        }[];
+    };
+    readonly composition: readonly CliProxyGatewayCompositionV1<Source>[];
+}
+export declare class CliProxyUpstreamRegistryV1<Source> {
+    readonly pluginGeneration: string;
+    private readonly sourceKey;
+    private readonly entries;
+    private readonly producerGenerations;
+    private readonly listeners;
+    private revision;
+    private disposed;
+    constructor(pluginGeneration: string, sourceKey: (source: Source) => string);
+    register(registration: CliProxyUpstreamRegistrationV1<Source>, registryGeneration: string, producer: CliProxyUpstreamProducerV1): CliProxyRegistryMutationResultV1;
+    revoke(input: CliProxyUpstreamRevocationV1, registryGeneration: string, producer: CliProxyUpstreamProducerV1): CliProxyRegistryMutationResultV1;
+    activateProducer(producer: CliProxyUpstreamProducerV1, registryGeneration: string): void;
+    disposeProducer(producer: CliProxyUpstreamProducerV1, registryGeneration: string): CliProxyRegistryMutationResultV1;
+    subscribe(listener: (revision: number) => void): () => void;
+    catalog(pluginGeneration: string): CliProxyModelCatalogV1 | CliProxyRegistryDiagnosticV1;
+    gatewayPlan(pluginGeneration: string): CliProxyGatewayPlanV1<Source> | CliProxyRegistryDiagnosticV1;
+    dispose(): void;
+    private notify;
+    private activeEntries;
+    private generationFailure;
+}
+export declare function createCliProxyUpstreamRegistrarV1<Source>(registry: CliProxyUpstreamRegistryV1<Source>, producer: CliProxyUpstreamProducerV1): CliProxyUpstreamRegistrarV1<Source>;

package/dist/bundled-plugins/@cordisx/plugin-cli-proxy-api/dist/types/service/values.d.ts

@@ -0,0 +1,9 @@
+import type { PlatformProviderJsonValue, PlatformProviderModelV1, PlatformProviderSessionDetailV1, PlatformProviderSessionRefV1, PlatformProviderSessionV1, PlatformProviderWorkspaceRefV1 } from '@cordisx/protocol/platform-provider/v1';
+export declare function object(value: unknown): Record<string, unknown> | undefined;
+export declare function text(value: unknown): string | undefined;
+export declare function workspace(value: unknown): PlatformProviderWorkspaceRefV1 | undefined;
+export declare function sessionRef(providerId: string, value: unknown): PlatformProviderSessionRefV1 | undefined;
+export declare function model(providerId: string, value: unknown): PlatformProviderModelV1 | undefined;
+export declare function session(providerId: string, value: unknown, rememberedModel?: string): PlatformProviderSessionV1 | undefined;
+export declare function sessionDetail(providerId: string, value: unknown, rememberedModel?: string): PlatformProviderSessionDetailV1 | undefined;
+export declare function json(value: unknown): PlatformProviderJsonValue;

package/dist/bundled-plugins/@cordisx/plugin-cli-proxy-api/dist/types/upstream-subscription-manager-messages.d.ts

@@ -0,0 +1,99 @@
+export interface UpstreamSubscriptionManagerMessages {
+    'upstream.group.account-subscriptions': undefined;
+    'upstream.group.cordisx-upstreams': undefined;
+    'upstream.group.runtime-status': undefined;
+    'upstream.status.readiness': {
+        readonly readiness: string;
+    };
+    'upstream.status.health': {
+        readonly health: string;
+    };
+    'upstream.status.auth-state': {
+        readonly state: string;
+    };
+    'upstream.status.model-count': {
+        readonly count: number;
+    };
+    'upstream.status.endpoint-origin': {
+        readonly origin: string;
+    };
+    'upstream.status.secret-configured': undefined;
+    'upstream.status.secret-missing': undefined;
+    'upstream.status.enabled': undefined;
+    'upstream.status.disabled': undefined;
+    'upstream.status.default': undefined;
+    'upstream.status.no-catalog': undefined;
+    'upstream.status.no-upstreams': undefined;
+    'upstream.status.service-unavailable': undefined;
+    'upstream.status.account-active': undefined;
+    'upstream.status.account-disabled': undefined;
+    'upstream.status.account-unavailable': undefined;
+    'upstream.status.account-runtime-only': undefined;
+    'upstream.status.account-source-file': undefined;
+    'upstream.status.account-source-memory': undefined;
+    'upstream.status.account-source-plugin': undefined;
+    'upstream.status.auth-oauth': undefined;
+    'upstream.status.auth-api-key': undefined;
+    'upstream.status.auth-file': undefined;
+    'upstream.status.auth-plugin-virtual': undefined;
+    'upstream.status.auth-unknown': undefined;
+    'upstream.status.oauth-pending': undefined;
+    'upstream.status.oauth-completed': undefined;
+    'upstream.status.oauth-cancelled': undefined;
+    'upstream.status.oauth-error': undefined;
+    'upstream.status.oauth-unknown': undefined;
+    'upstream.status.account-controls-unavailable': undefined;
+    'upstream.status.account-count': {
+        readonly count: number;
+    };
+    'upstream.status.no-accounts': undefined;
+    'upstream.status.service-auth': {
+        readonly state: string;
+    };
+    'upstream.status.ready': undefined;
+    'upstream.status.degraded': undefined;
+    'upstream.status.failed': undefined;
+    'upstream.status.stopped': undefined;
+    'upstream.status.healthy': undefined;
+    'upstream.status.warning': undefined;
+    'upstream.status.critical': undefined;
+    'upstream.status.missing': undefined;
+    'upstream.status.authenticating': undefined;
+    'upstream.status.authenticated': undefined;
+    'upstream.status.expired': undefined;
+    'upstream.status.logged-out': undefined;
+    'upstream.status.unknown': undefined;
+    'upstream.status.no-accounts-description': undefined;
+    'upstream.status.no-upstreams-description': undefined;
+    'upstream.status.configuration-unavailable': undefined;
+    'upstream.field.revision': undefined;
+    'upstream.field.generation': undefined;
+    'upstream.field.sequence': undefined;
+    'upstream.field.provider': undefined;
+    'upstream.field.source': undefined;
+    'upstream.field.auth-type': undefined;
+    'upstream.field.account': undefined;
+    'upstream.field.project': undefined;
+    'upstream.field.note': undefined;
+    'upstream.field.updated': undefined;
+    'upstream.field.last-refresh': undefined;
+    'upstream.field.technical-details': undefined;
+    'upstream.field.endpoint': undefined;
+    'upstream.field.credential': undefined;
+    'upstream.field.models': undefined;
+    'upstream.action.refresh': undefined;
+    'upstream.action.open-plugin-configuration': undefined;
+    'upstream.action.login-service': undefined;
+    'upstream.action.logout-service': undefined;
+    'upstream.state.operation-error': undefined;
+    'upstream.action.oauth-start': {
+        readonly provider: string;
+    };
+    'upstream.action.oauth-cancel': undefined;
+    'upstream.action.enable': undefined;
+    'upstream.action.disable': undefined;
+    'state.loading': undefined;
+    'state.error': {
+        readonly message: string;
+    };
+}

package/dist/bundled-plugins/@cordisx/plugin-cli-proxy-api/dist/types/upstream-subscription-manager-page.d.ts

@@ -0,0 +1,7 @@
+import type { Context } from '@deepseek-ai/cordis';
+import type { CordisXReactPageProps } from 'cordisx/contracts';
+import type { UpstreamSubscriptionManagerMessages } from './upstream-subscription-manager-messages.js';
+import './upstream-subscription-manager-page.css';
+type PageProps = CordisXReactPageProps<UpstreamSubscriptionManagerMessages>;
+export declare function createUpstreamSubscriptionManagerPage(managedServices: Context['managedServices'] | undefined, manager: Context['manager'] | undefined, notifications: Context['notifications']): (props: PageProps) => import("react").JSX.Element;
+export {};