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

package/dist/bundled-plugins/@cordisx/plugin-cli-proxy-api/dist/gateway.mjs

@@ -0,0 +1,1337 @@
+// src/service/gateway.ts
+import { createHash as createHash4 } from "node:crypto";
+
+// src/service/gateway-definition.ts
+import { createHash } from "node:crypto";
+var 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";
+var 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";
+var 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";
+var CLI_PROXY_MANAGEMENT_AUTH_FILES_SCHEMA_V1 = "https://raw.githubusercontent.com/cordisx/plugin-cli-proxy-api/main/schemas/cli-proxy-management-auth-files.v1.schema.json";
+var CLI_PROXY_MANAGEMENT_OPERATION_SCHEMA_V1 = "https://raw.githubusercontent.com/cordisx/plugin-cli-proxy-api/main/schemas/cli-proxy-management-operation.v1.schema.json";
+var CLI_PROXY_GATEWAY_SERVICE_ID = "gateway-runtime";
+var CLI_PROXY_GATEWAY_MANAGEMENT_V1 = Object.freeze({
+  credentialSlot: "management-key",
+  path: "/v0/management"
+});
+var cliProxyGatewayDefinition = {
+  $schema: "https://raw.githubusercontent.com/cordisx/cordisx-protocol/main/schemas/managed-service-definition.v1.schema.json",
+  contract: "cordisx.managed-service-definition/v1",
+  schemaVersion: 1,
+  serviceId: CLI_PROXY_GATEWAY_SERVICE_ID,
+  launch: {
+    executable: { kind: "named-command", command: "cli-proxy-api" },
+    arguments: [],
+    startupTimeoutMs: 15e3
+  },
+  configuration: {
+    template: "./config/cli-proxy-api.yaml",
+    format: "yaml",
+    delivery: { kind: "generation-private-process-file", argument: "--config" }
+  },
+  compositionOrigins: [{ id: "api", path: "/v1" }],
+  protectedBindings: [
+    {
+      slot: "assigned-port",
+      source: "host-assigned-loopback",
+      target: "configuration",
+      pointer: "/port",
+      serialization: "port"
+    },
+    {
+      slot: "gateway-key",
+      source: "generated-local-key",
+      target: "configuration",
+      pointer: "/api-keys/0"
+    },
+    {
+      slot: CLI_PROXY_GATEWAY_MANAGEMENT_V1.credentialSlot,
+      source: "generated-local-key",
+      target: "configuration",
+      pointer: "/remote-management/secret-key"
+    },
+    {
+      slot: "codex-upstreams",
+      source: "composition",
+      target: "configuration",
+      pointer: "/codex-api-key",
+      valueSchema: CLI_PROXY_GATEWAY_CODEX_UPSTREAMS_SCHEMA_V1
+    },
+    {
+      slot: "openai-upstreams",
+      source: "composition",
+      target: "configuration",
+      pointer: "/openai-compatibility",
+      valueSchema: CLI_PROXY_GATEWAY_OPENAI_UPSTREAMS_SCHEMA_V1
+    }
+  ],
+  authentication: { mode: "none" },
+  httpAuthentication: { mode: "authorization-header", scheme: "Bearer", slot: "gateway-key" },
+  discovery: { kind: "host-assigned-loopback" },
+  operations: [
+    {
+      operationId: "gateway.models.list",
+      method: "GET",
+      path: "/v1/models",
+      responseSchema: CLI_PROXY_GATEWAY_MODEL_CATALOG_SCHEMA_V1,
+      timeoutMs: 5e3
+    },
+    {
+      operationId: "gateway.management.accounts.list",
+      method: "GET",
+      path: "/v0/management/auth-files",
+      responseSchema: CLI_PROXY_MANAGEMENT_AUTH_FILES_SCHEMA_V1,
+      timeoutMs: 5e3,
+      httpAuthentication: { mode: "authorization-header", scheme: "Bearer", slot: "management-key" }
+    },
+    {
+      operationId: "gateway.management.accounts.toggle",
+      method: "PATCH",
+      path: "/v0/management/auth-files/status",
+      requestSchema: CLI_PROXY_MANAGEMENT_OPERATION_SCHEMA_V1,
+      responseSchema: CLI_PROXY_MANAGEMENT_OPERATION_SCHEMA_V1,
+      timeoutMs: 5e3,
+      httpAuthentication: { mode: "authorization-header", scheme: "Bearer", slot: "management-key" }
+    },
+    ...["anthropic", "codex", "antigravity", "kimi", "xai"].map((provider) => ({
+      operationId: `gateway.management.oauth.${provider}.start`,
+      method: "GET",
+      path: `/v0/management/${provider}-auth-url`,
+      requestSchema: CLI_PROXY_MANAGEMENT_OPERATION_SCHEMA_V1,
+      requestEncoding: "query",
+      responseSchema: CLI_PROXY_MANAGEMENT_OPERATION_SCHEMA_V1,
+      timeoutMs: 3e4,
+      httpAuthentication: { mode: "authorization-header", scheme: "Bearer", slot: "management-key" }
+    })),
+    {
+      operationId: "gateway.management.oauth.poll",
+      method: "GET",
+      path: "/v0/management/get-auth-status",
+      requestSchema: CLI_PROXY_MANAGEMENT_OPERATION_SCHEMA_V1,
+      requestEncoding: "query",
+      responseSchema: CLI_PROXY_MANAGEMENT_OPERATION_SCHEMA_V1,
+      timeoutMs: 5e3,
+      httpAuthentication: { mode: "authorization-header", scheme: "Bearer", slot: "management-key" }
+    },
+    {
+      operationId: "gateway.management.oauth.cancel",
+      method: "DELETE",
+      path: "/v0/management/oauth-session",
+      requestSchema: CLI_PROXY_MANAGEMENT_OPERATION_SCHEMA_V1,
+      requestEncoding: "query",
+      responseSchema: CLI_PROXY_MANAGEMENT_OPERATION_SCHEMA_V1,
+      timeoutMs: 5e3,
+      httpAuthentication: { mode: "authorization-header", scheme: "Bearer", slot: "management-key" }
+    }
+  ],
+  health: { path: "/v1/models", intervalMs: 250, timeoutMs: 1e3 }
+};
+var cliProxyGatewayDefinitionRevision = `sha256:${createHash("sha256").update(
+  JSON.stringify(cliProxyGatewayDefinition)
+).digest("hex")}`;
+
+// src/service/gateway-ui.ts
+import { createHash as createHash2 } from "node:crypto";
+var activeState;
+function bindGatewayUIState(state) {
+  activeState = state;
+  return () => {
+    if (activeState === state) activeState = void 0;
+  };
+}
+function record(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function stringValue(value) {
+  return typeof value === "string" && value.trim() !== "" ? value.trim() : void 0;
+}
+function numberValue(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function booleanValue(value) {
+  return typeof value === "boolean" ? value : void 0;
+}
+function providerId(value) {
+  const normalized = value?.toLowerCase() ?? "unknown";
+  if (normalized === "claude") return "anthropic";
+  if (normalized === "openai") return "codex";
+  if (["anthropic", "codex", "antigravity", "kimi", "xai"].includes(normalized)) {
+    return normalized;
+  }
+  const safe = normalized.replace(/[^a-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "") || "unknown";
+  return `custom:${safe}`;
+}
+function revision(value) {
+  const digest2 = createHash2("sha256").update(JSON.stringify(value)).digest("hex").slice(0, 12);
+  return Number.parseInt(digest2, 16);
+}
+function bindingMatches(left, right) {
+  return left.bindingId === right.bindingId && left.identity.pluginId === right.identity.pluginId && left.identity.serviceId === right.identity.serviceId && left.scope.profileId === right.scope.profileId && left.scope.generation === right.scope.generation;
+}
+function mapCatalog(state, catalog, binding, serviceGeneration, sequence) {
+  const plan = state.registry.gatewayPlan(state.pluginGeneration);
+  const sourceByProvider = "code" in plan ? /* @__PURE__ */ new Map() : new Map(plan.composition.map((item) => [item.upstreamId, item.source]));
+  return Object.freeze({
+    $schema: "https://raw.githubusercontent.com/cordisx/cordisx-protocol/main/schemas/managed-service-cli-proxy-catalog.v1.schema.json",
+    contract: "cordisx.managed-service-cli-proxy-catalog/v1",
+    schemaVersion: 1,
+    binding,
+    sequence,
+    observedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    revision: catalog.registryRevision,
+    serviceGeneration,
+    providers: Object.freeze(catalog.groups.flatMap(
+      (group) => group.providers.map((provider) => {
+        const source = sourceByProvider.get(provider.providerId);
+        const authorized = state.authorization.get(provider.providerId) ?? false;
+        const active = state.activeRevision === catalog.registryRevision;
+        return Object.freeze({
+          id: provider.providerId,
+          displayName: provider.displayName,
+          enabled: active,
+          endpoint: Object.freeze({
+            origin: source === void 0 ? "managed://unavailable" : `managed://${source.pluginId}/${source.serviceId}`,
+            secretConfigured: authorized
+          }),
+          health: active ? "healthy" : "warning",
+          auth: authorized ? "authenticated" : "missing",
+          models: Object.freeze({
+            mappings: Object.freeze(provider.models.flatMap(
+              (model) => model.sourceModelIds.map(
+                (sourceModelId) => Object.freeze({
+                  sourceModelId,
+                  modelId: model.gatewayModelId,
+                  displayName: model.displayName,
+                  enabled: active,
+                  isDefault: model.isDefault
+                })
+              )
+            ))
+          })
+        });
+      })
+    ))
+  });
+}
+function mapAccount(value) {
+  const item = record(value);
+  const accountId = stringValue(item.id) ?? stringValue(item.name);
+  if (accountId === void 0) return void 0;
+  const disabled = booleanValue(item.disabled) ?? false;
+  const unavailable = booleanValue(item.unavailable) ?? false;
+  const rawModels = Array.isArray(item.models) ? item.models : [];
+  const models = rawModels.flatMap((model) => {
+    const entry = record(model);
+    const id = stringValue(entry.id) ?? stringValue(entry.name);
+    return id === void 0 ? [] : [{
+      id,
+      ...stringValue(entry.display_name) === void 0 ? {} : { displayName: stringValue(entry.display_name) },
+      ...stringValue(entry.type) === void 0 ? {} : { type: stringValue(entry.type) },
+      ...stringValue(entry.owned_by) === void 0 ? {} : { ownedBy: stringValue(entry.owned_by) }
+    }];
+  });
+  const source = stringValue(item.source);
+  const quota = record(item.quota);
+  const quotaSignals = Object.fromEntries(
+    Object.entries(record(quota.signals)).flatMap(([key, signal]) => typeof signal === "string" ? [[key, signal]] : [])
+  );
+  const provider = providerId(stringValue(item.provider) ?? stringValue(item.type));
+  const runtimeOnly = booleanValue(item.runtime_only) ?? false;
+  const authKind = runtimeOnly ? "plugin-virtual" : provider.startsWith("custom:") ? "unknown" : "oauth";
+  return Object.freeze({
+    accountId,
+    authIndex: stringValue(item.auth_index) ?? accountId,
+    provider,
+    label: stringValue(item.label) ?? stringValue(item.email) ?? stringValue(item.account) ?? accountId,
+    status: disabled ? "disabled" : unavailable ? "unavailable" : "active",
+    ...stringValue(item.status_message) === void 0 ? {} : { statusMessage: "Account unavailable" },
+    disabled,
+    unavailable,
+    authKind,
+    sourceKind: source === "file" || source === "plugin" ? source : "memory",
+    runtimeOnly,
+    ...stringValue(item.email) === void 0 ? {} : { email: stringValue(item.email) },
+    ...stringValue(item.project_id) === void 0 ? {} : { projectId: stringValue(item.project_id) },
+    ...stringValue(item.account_type) === void 0 ? {} : { accountType: stringValue(item.account_type) },
+    ...stringValue(item.account) === void 0 ? {} : { account: stringValue(item.account) },
+    ...stringValue(item.note) === void 0 ? {} : { note: stringValue(item.note) },
+    ...numberValue(item.priority) === void 0 ? {} : { priority: numberValue(item.priority) },
+    ...numberValue(item.weight) === void 0 ? {} : { weight: numberValue(item.weight) },
+    ...booleanValue(item.websockets) === void 0 ? {} : { websockets: booleanValue(item.websockets) },
+    ...numberValue(item.request_retry) === void 0 ? {} : { requestRetry: numberValue(item.request_retry) },
+    ...numberValue(item.success) === void 0 ? {} : { success: numberValue(item.success) },
+    ...numberValue(item.failed) === void 0 ? {} : { failed: numberValue(item.failed) },
+    ...stringValue(item.created_at) === void 0 ? {} : { createdAt: stringValue(item.created_at) },
+    ...stringValue(item.updated_at) === void 0 ? {} : { updatedAt: stringValue(item.updated_at) },
+    ...stringValue(item.last_refresh) === void 0 ? {} : { lastRefreshAt: stringValue(item.last_refresh) },
+    ...stringValue(item.next_retry_after) === void 0 ? {} : { nextRetryAfter: stringValue(item.next_retry_after) },
+    ...models.length === 0 ? {} : { models: Object.freeze(models) },
+    ...Object.keys(quotaSignals).length === 0 ? {} : { quotaSignals: Object.freeze(quotaSignals) }
+  });
+}
+async function invoke(client, registration, operationId, value, signal) {
+  const acquired = await client.acquire(registration.binding.identity, { signal });
+  if (acquired.status !== "ready") return void 0;
+  try {
+    const result = await client.invoke(acquired.lease, operationId, value, { signal });
+    return result.status === "accepted" ? result.value : void 0;
+  } finally {
+    client.release(acquired.lease);
+  }
+}
+var managedServiceUI = Object.freeze({
+  serviceId: CLI_PROXY_GATEWAY_SERVICE_ID,
+  create({ binding, registration, client, signal }) {
+    const state = activeState;
+    let sequence = 0;
+    let accountsRevision = 0;
+    const sessions = /* @__PURE__ */ new Map();
+    const unavailableAccounts = () => Object.freeze({ status: "unavailable", code: "management-disabled" });
+    const readAccounts = async () => {
+      if (state === void 0 || signal.aborted) return unavailableAccounts();
+      const projection = await registration.inspect();
+      const value = await invoke(client, registration, "gateway.management.accounts.list", void 0, signal);
+      const files = record(value).files;
+      if (!Array.isArray(files)) return unavailableAccounts();
+      const accounts = Object.freeze(files.flatMap((item) => {
+        const mapped = mapAccount(item);
+        return mapped === void 0 ? [] : [mapped];
+      }));
+      accountsRevision = revision(accounts);
+      sequence += 1;
+      return Object.freeze({
+        status: "available",
+        accounts: Object.freeze({
+          $schema: "https://raw.githubusercontent.com/cordisx/cordisx-protocol/main/schemas/managed-service-cli-proxy-accounts.v1.schema.json",
+          contract: "cordisx.managed-service-cli-proxy-accounts/v1",
+          schemaVersion: 1,
+          binding,
+          sequence,
+          observedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          revision: accountsRevision,
+          serviceGeneration: projection.binding.serviceGeneration,
+          accounts
+        })
+      });
+    };
+    return Object.freeze({
+      async readCatalog() {
+        if (state === void 0 || signal.aborted) {
+          return Object.freeze({ status: "unavailable", code: "owner-unavailable" });
+        }
+        const catalog = state.registry.catalog(state.pluginGeneration);
+        if ("code" in catalog) {
+          return Object.freeze({ status: "unavailable", code: "stale-generation" });
+        }
+        const projection = await registration.inspect();
+        sequence += 1;
+        return Object.freeze({
+          status: "available",
+          catalog: mapCatalog(state, catalog, binding, projection.binding.serviceGeneration, sequence)
+        });
+      },
+      readAccounts,
+      async toggleAccount(request) {
+        if (!bindingMatches(request.binding, binding) || request.expectedRevision !== accountsRevision) {
+          return Object.freeze({
+            $schema: "https://raw.githubusercontent.com/cordisx/cordisx-protocol/main/schemas/managed-service-cli-proxy-account-toggle-result.v1.schema.json",
+            contract: "cordisx.managed-service-cli-proxy-account-toggle-result/v1",
+            schemaVersion: 1,
+            requestId: request.requestId,
+            binding,
+            status: "denied",
+            error: Object.freeze({ code: "stale-revision", message: "account revision changed" })
+          });
+        }
+        const result = await invoke(client, registration, "gateway.management.accounts.toggle", {
+          name: request.accountId,
+          ...request.authIndex === void 0 ? {} : { auth_index: request.authIndex },
+          disabled: request.disabled
+        }, signal);
+        sequence += 1;
+        if (result !== void 0 && state !== void 0 && !signal.aborted) {
+          await state.refreshGatewayModels().catch(() => void 0);
+        }
+        return result === void 0 ? Object.freeze({
+          $schema: "https://raw.githubusercontent.com/cordisx/cordisx-protocol/main/schemas/managed-service-cli-proxy-account-toggle-result.v1.schema.json",
+          contract: "cordisx.managed-service-cli-proxy-account-toggle-result/v1",
+          schemaVersion: 1,
+          requestId: request.requestId,
+          binding,
+          status: "failed",
+          error: Object.freeze({ code: "management-disabled", message: "management API unavailable" })
+        }) : Object.freeze({
+          $schema: "https://raw.githubusercontent.com/cordisx/cordisx-protocol/main/schemas/managed-service-cli-proxy-account-toggle-result.v1.schema.json",
+          contract: "cordisx.managed-service-cli-proxy-account-toggle-result/v1",
+          schemaVersion: 1,
+          requestId: request.requestId,
+          binding,
+          status: "accepted",
+          accountId: request.accountId,
+          disabled: request.disabled,
+          sequence
+        });
+      },
+      async startOAuth(request) {
+        if (!bindingMatches(request.binding, binding) || request.expectedRevision !== accountsRevision) {
+          return Object.freeze({
+            $schema: "https://raw.githubusercontent.com/cordisx/cordisx-protocol/main/schemas/managed-service-cli-proxy-oauth-result.v1.schema.json",
+            contract: "cordisx.managed-service-cli-proxy-oauth-result/v1",
+            schemaVersion: 1,
+            requestId: request.requestId,
+            binding,
+            status: "denied",
+            error: Object.freeze({ code: "stale-revision", message: "account revision changed" })
+          });
+        }
+        const endpoints = {
+          anthropic: "gateway.management.oauth.anthropic.start",
+          codex: "gateway.management.oauth.codex.start",
+          antigravity: "gateway.management.oauth.antigravity.start",
+          kimi: "gateway.management.oauth.kimi.start",
+          xai: "gateway.management.oauth.xai.start"
+        };
+        const endpoint = endpoints[request.provider];
+        const value = endpoint === void 0 ? void 0 : await invoke(client, registration, endpoint, { is_webui: true }, signal);
+        const response = record(value);
+        const authorizationUrl = stringValue(response.url);
+        const sessionId = stringValue(response.state);
+        if (authorizationUrl === void 0 || sessionId === void 0) {
+          return Object.freeze({
+            $schema: "https://raw.githubusercontent.com/cordisx/cordisx-protocol/main/schemas/managed-service-cli-proxy-oauth-result.v1.schema.json",
+            contract: "cordisx.managed-service-cli-proxy-oauth-result/v1",
+            schemaVersion: 1,
+            requestId: request.requestId,
+            binding,
+            status: "unavailable",
+            error: Object.freeze({ code: "unsupported-provider", message: "OAuth provider unavailable" })
+          });
+        }
+        sessions.set(sessionId, request.provider);
+        sequence += 1;
+        return Object.freeze({
+          $schema: "https://raw.githubusercontent.com/cordisx/cordisx-protocol/main/schemas/managed-service-cli-proxy-oauth-result.v1.schema.json",
+          contract: "cordisx.managed-service-cli-proxy-oauth-result/v1",
+          schemaVersion: 1,
+          requestId: request.requestId,
+          binding,
+          status: "accepted",
+          sessionId,
+          authorizationUrl,
+          sequence
+        });
+      },
+      async pollOAuth(sessionId) {
+        const value = sessions.has(sessionId) ? await invoke(client, registration, "gateway.management.oauth.poll", { state: sessionId }, signal) : void 0;
+        const response = record(value);
+        const status = stringValue(response.status);
+        const stateValue = status === "ok" ? "completed" : status === "error" ? "error" : status === "wait" ? "wait" : "unknown";
+        if (stateValue === "completed" || stateValue === "error") sessions.delete(sessionId);
+        if (stateValue === "completed" && state !== void 0 && !signal.aborted) {
+          await state.refreshGatewayModels().catch(() => void 0);
+        }
+        return Object.freeze({
+          $schema: "https://raw.githubusercontent.com/cordisx/cordisx-protocol/main/schemas/managed-service-cli-proxy-oauth-status.v1.schema.json",
+          contract: "cordisx.managed-service-cli-proxy-oauth-status/v1",
+          schemaVersion: 1,
+          binding,
+          sessionId,
+          state: stateValue,
+          ...stringValue(response.error) === void 0 ? {} : { error: Object.freeze({ code: "authentication-failed", message: "Authentication failed" }) },
+          sequence: ++sequence
+        });
+      },
+      async cancelOAuth(request) {
+        if (!bindingMatches(request.binding, binding) || request.expectedRevision !== accountsRevision) {
+          return Object.freeze({
+            $schema: "https://raw.githubusercontent.com/cordisx/cordisx-protocol/main/schemas/managed-service-cli-proxy-oauth-cancel-result.v1.schema.json",
+            contract: "cordisx.managed-service-cli-proxy-oauth-cancel-result/v1",
+            schemaVersion: 1,
+            requestId: request.requestId,
+            binding,
+            status: "denied",
+            error: Object.freeze({ code: "stale-revision", message: "account revision changed" })
+          });
+        }
+        const value = sessions.has(request.sessionId) ? await invoke(client, registration, "gateway.management.oauth.cancel", { state: request.sessionId }, signal) : void 0;
+        const cancelled = booleanValue(record(value).cancelled) ?? false;
+        if (cancelled) sessions.delete(request.sessionId);
+        if (value === void 0) {
+          return Object.freeze({
+            $schema: "https://raw.githubusercontent.com/cordisx/cordisx-protocol/main/schemas/managed-service-cli-proxy-oauth-cancel-result.v1.schema.json",
+            contract: "cordisx.managed-service-cli-proxy-oauth-cancel-result/v1",
+            schemaVersion: 1,
+            requestId: request.requestId,
+            binding,
+            status: "failed",
+            error: Object.freeze({ code: "management-disabled", message: "management API unavailable" })
+          });
+        }
+        return Object.freeze({
+          $schema: "https://raw.githubusercontent.com/cordisx/cordisx-protocol/main/schemas/managed-service-cli-proxy-oauth-cancel-result.v1.schema.json",
+          contract: "cordisx.managed-service-cli-proxy-oauth-cancel-result/v1",
+          schemaVersion: 1,
+          requestId: request.requestId,
+          binding,
+          status: "accepted",
+          sessionId: request.sessionId,
+          cancelled,
+          sequence: ++sequence
+        });
+      }
+    });
+  }
+});
+
+// src/service/upstream-registry.ts
+import { createHash as createHash3 } from "node:crypto";
+var CLI_PROXY_UPSTREAM_DESCRIPTOR_SCHEMA_V1 = "https://raw.githubusercontent.com/cordisx/plugin-cli-proxy-api/main/schemas/cli-proxy-upstream-descriptor.v1.schema.json";
+var CLI_PROXY_UPSTREAM_DESCRIPTOR_CONTRACT_V1 = "cordisx.cli-proxy-upstream-descriptor/v1";
+var CLI_PROXY_MODEL_CATALOG_CONTRACT_V1 = "cordisx.cli-proxy-model-catalog/v1";
+var CLI_PROXY_GATEWAY_PLAN_CONTRACT_V1 = "cordisx.cli-proxy-gateway-plan/v1";
+var CLI_PROXY_UPSTREAM_REGISTRY_SERVICE_V1 = "cliProxyUpstreams";
+var ID_PATTERN = /^[a-z0-9][a-z0-9._-]{0,95}$/;
+var PREFIX_PATTERN = /^[a-z0-9][a-z0-9._-]{0,95}$/;
+var MAX_MODELS = 256;
+var MAX_REGISTRATIONS = 64;
+function rejection(failure) {
+  return { status: "rejected", diagnostic: failure };
+}
+function isText(value, maximum) {
+  return value.length > 0 && value.length <= maximum && value === value.trim() && !/[\u0000-\u001f\u007f]/.test(value);
+}
+function sameStrings(left, right) {
+  return left.length === right.length && left.every((value, index) => value === right[index]);
+}
+function normalizedModalities(values) {
+  return [...new Set(values ?? [])].sort();
+}
+function validateDescriptor(descriptor) {
+  if (descriptor.$schema !== CLI_PROXY_UPSTREAM_DESCRIPTOR_SCHEMA_V1 || descriptor.contract !== CLI_PROXY_UPSTREAM_DESCRIPTOR_CONTRACT_V1 || descriptor.schemaVersion !== 1) {
+    return { code: "invalid-registration", field: "contract", message: "Unsupported upstream descriptor contract" };
+  }
+  if (!ID_PATTERN.test(descriptor.upstreamId)) {
+    return { code: "invalid-registration", field: "upstreamId", message: "Invalid upstream id" };
+  }
+  if (!isText(descriptor.displayName, 200)) {
+    return { code: "invalid-registration", field: "displayName", message: "Invalid upstream display name" };
+  }
+  if (descriptor.wireApi !== "responses" && descriptor.wireApi !== "chat-completions") {
+    return { code: "invalid-registration", field: "wireApi", message: "Unsupported upstream wire API" };
+  }
+  if (!Number.isSafeInteger(descriptor.revision) || descriptor.revision < 1) {
+    return { code: "invalid-registration", field: "revision", message: "Revision must be a positive safe integer" };
+  }
+  if (!Number.isSafeInteger(descriptor.order) || descriptor.order < -1e3 || descriptor.order > 1e3) {
+    return { code: "invalid-registration", field: "order", message: "Provider order is outside the supported range" };
+  }
+  if (!Number.isSafeInteger(descriptor.requestTimeoutMs) || descriptor.requestTimeoutMs < 1e3 || descriptor.requestTimeoutMs > 12e4) {
+    return {
+      code: "invalid-registration",
+      field: "requestTimeoutMs",
+      message: "Request timeout is outside the supported range"
+    };
+  }
+  if (!ID_PATTERN.test(descriptor.group.groupId) || !isText(descriptor.group.displayName, 200)) {
+    return { code: "invalid-registration", field: "group", message: "Invalid upstream group" };
+  }
+  if (!Number.isSafeInteger(descriptor.group.order) || descriptor.group.order < -1e3 || descriptor.group.order > 1e3) {
+    return { code: "invalid-registration", field: "group.order", message: "Group order is outside the supported range" };
+  }
+  const prefix = descriptor.prefix ?? descriptor.upstreamId;
+  if (!PREFIX_PATTERN.test(prefix)) {
+    return { code: "invalid-registration", field: "prefix", message: "Invalid gateway prefix" };
+  }
+  if (descriptor.models.length === 0 || descriptor.models.length > MAX_MODELS) {
+    return { code: "invalid-registration", field: "models", message: "Model routes are outside the supported range" };
+  }
+  const sourceModels = /* @__PURE__ */ new Set();
+  const aliases = /* @__PURE__ */ new Map();
+  const defaults = /* @__PURE__ */ new Set();
+  for (const route of descriptor.models) {
+    if (!isText(route.sourceModelId, 256) || !isText(route.modelId, 256)) {
+      return { code: "invalid-registration", field: "models", message: "Invalid model identity" };
+    }
+    if (route.displayName !== void 0 && !isText(route.displayName, 200)) {
+      return { code: "invalid-registration", field: "models.displayName", message: "Invalid model display name" };
+    }
+    if (sourceModels.has(route.sourceModelId)) {
+      return { code: "conflicting-model-alias", field: "models.sourceModelId", message: "Duplicate source model id" };
+    }
+    sourceModels.add(route.sourceModelId);
+    if (!route.enabled) continue;
+    if (route.isDefault) defaults.add(route.modelId);
+    const modalities = normalizedModalities(route.inputModalities);
+    if (modalities.some((value) => value !== "text" && value !== "image" && value !== "audio")) {
+      return { code: "invalid-registration", field: "models.inputModalities", message: "Unsupported input modality" };
+    }
+    const first = aliases.get(route.modelId);
+    if (first !== void 0 && ((first.displayName ?? first.modelId) !== (route.displayName ?? route.modelId) || first.isDefault !== route.isDefault || !sameStrings(normalizedModalities(first.inputModalities), modalities))) {
+      return {
+        code: "conflicting-model-alias",
+        field: "models.modelId",
+        message: "Pooled model aliases must have identical public metadata"
+      };
+    }
+    aliases.set(route.modelId, route);
+  }
+  if (aliases.size === 0) {
+    return { code: "invalid-registration", field: "models", message: "At least one enabled model route is required" };
+  }
+  if (defaults.size > 1) {
+    return {
+      code: "conflicting-default",
+      field: "models.isDefault",
+      message: "Only one public default model is allowed"
+    };
+  }
+  return void 0;
+}
+function compareOrderThenId(left, right) {
+  return left.order - right.order || left.id.localeCompare(right.id);
+}
+function stableValue(value) {
+  if (Array.isArray(value)) return value.map(stableValue);
+  if (value === null || typeof value !== "object") return value;
+  return Object.fromEntries(
+    Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(
+      ([key, item]) => [key, stableValue(item)]
+    )
+  );
+}
+function stableStringify(value) {
+  return JSON.stringify(stableValue(value));
+}
+function digest(value) {
+  return `sha256:${createHash3("sha256").update(stableStringify(value)).digest("hex")}`;
+}
+var CliProxyUpstreamRegistryV1 = class {
+  constructor(pluginGeneration, sourceKey2) {
+    this.pluginGeneration = pluginGeneration;
+    this.sourceKey = sourceKey2;
+    if (!isText(pluginGeneration, 256)) throw new Error("Invalid plugin generation");
+  }
+  pluginGeneration;
+  sourceKey;
+  entries = /* @__PURE__ */ new Map();
+  producerGenerations = /* @__PURE__ */ new Map();
+  listeners = /* @__PURE__ */ new Set();
+  revision = 0;
+  disposed = false;
+  register(registration, registryGeneration, producer) {
+    const generationFailure = this.generationFailure(registryGeneration, producer);
+    if (generationFailure !== void 0) return generationFailure;
+    const current = this.entries.get(registration.descriptor.upstreamId);
+    if (current !== void 0 && current.producer.pluginId !== producer.pluginId) {
+      return rejection({
+        code: "conflicting-producer",
+        field: "upstreamId",
+        message: "Upstream is owned by another producer"
+      });
+    }
+    if (current !== void 0 && current.producer.pluginGeneration !== producer.pluginGeneration) {
+      return {
+        status: "stale-generation",
+        diagnostic: { code: "stale-generation", message: "Upstream producer generation is stale" }
+      };
+    }
+    const validation = validateDescriptor(registration.descriptor);
+    if (validation !== void 0) return rejection(validation);
+    const sourceKey2 = this.sourceKey(registration.source);
+    if (!isText(sourceKey2, 512)) {
+      return rejection({ code: "invalid-registration", field: "source", message: "Invalid upstream source reference" });
+    }
+    if (current !== void 0) {
+      if (registration.descriptor.revision < current.descriptor.revision) {
+        return rejection({ code: "stale-revision", field: "revision", message: "Upstream revision is stale" });
+      }
+      if (registration.descriptor.revision === current.descriptor.revision) {
+        return stableStringify(registration.descriptor) === stableStringify(current.descriptor) && sourceKey2 === current.sourceKey ? { status: "unchanged", registryRevision: this.revision } : rejection({
+          code: "stale-revision",
+          field: "revision",
+          message: "Revision was reused with different content"
+        });
+      }
+    } else if (this.entries.size >= MAX_REGISTRATIONS) {
+      return rejection({ code: "capacity-exceeded", message: "Upstream registry capacity was reached" });
+    }
+    for (const [upstreamId, entry] of this.entries) {
+      if (upstreamId === registration.descriptor.upstreamId) continue;
+      if (entry.sourceKey === sourceKey2) {
+        return rejection({
+          code: "conflicting-source",
+          field: "source",
+          message: "Upstream source is already registered"
+        });
+      }
+      if (entry.descriptor.enabled && registration.descriptor.enabled) {
+        if ((entry.descriptor.prefix ?? entry.descriptor.upstreamId) === (registration.descriptor.prefix ?? registration.descriptor.upstreamId)) {
+          return rejection({
+            code: "conflicting-prefix",
+            field: "prefix",
+            message: "Gateway prefix is already registered"
+          });
+        }
+        if (entry.descriptor.group.groupId === registration.descriptor.group.groupId && (entry.descriptor.group.displayName !== registration.descriptor.group.displayName || entry.descriptor.group.order !== registration.descriptor.group.order)) {
+          return rejection({ code: "conflicting-group", field: "group", message: "Group metadata is inconsistent" });
+        }
+      }
+    }
+    this.entries.set(registration.descriptor.upstreamId, {
+      source: registration.source,
+      sourceKey: sourceKey2,
+      producer,
+      descriptor: structuredClone(registration.descriptor)
+    });
+    this.revision += 1;
+    this.notify();
+    return { status: current === void 0 ? "registered" : "updated", registryRevision: this.revision };
+  }
+  revoke(input, registryGeneration, producer) {
+    const generationFailure = this.generationFailure(registryGeneration, producer);
+    if (generationFailure !== void 0) return generationFailure;
+    const current = this.entries.get(input.upstreamId);
+    if (current === void 0) {
+      return rejection({ code: "not-found", field: "upstreamId", message: "Upstream is not registered" });
+    }
+    if (current.producer.pluginId !== producer.pluginId) {
+      return rejection({
+        code: "conflicting-producer",
+        field: "upstreamId",
+        message: "Upstream is owned by another producer"
+      });
+    }
+    if (current.producer.pluginGeneration !== producer.pluginGeneration) {
+      return {
+        status: "stale-generation",
+        diagnostic: { code: "stale-generation", message: "Upstream producer generation is stale" }
+      };
+    }
+    if (input.expectedRevision !== current.descriptor.revision) {
+      return rejection({ code: "stale-revision", field: "expectedRevision", message: "Upstream revision is stale" });
+    }
+    this.entries.delete(input.upstreamId);
+    this.revision += 1;
+    this.notify();
+    return { status: "revoked", registryRevision: this.revision };
+  }
+  activateProducer(producer, registryGeneration) {
+    if (this.disposed || registryGeneration !== this.pluginGeneration) {
+      throw new Error("Upstream registry generation is stale");
+    }
+    if (!ID_PATTERN.test(producer.pluginId) || !isText(producer.pluginGeneration, 256)) {
+      throw new Error("Invalid upstream producer authority");
+    }
+    const currentGeneration = this.producerGenerations.get(producer.pluginId);
+    if (currentGeneration === producer.pluginGeneration) return;
+    this.producerGenerations.set(producer.pluginId, producer.pluginGeneration);
+    let removed = false;
+    for (const [upstreamId, entry] of this.entries) {
+      if (entry.producer.pluginId !== producer.pluginId) continue;
+      this.entries.delete(upstreamId);
+      removed = true;
+    }
+    if (removed) {
+      this.revision += 1;
+      this.notify();
+    }
+  }
+  disposeProducer(producer, registryGeneration) {
+    const generationFailure = this.generationFailure(registryGeneration, producer);
+    if (generationFailure !== void 0) return generationFailure;
+    this.producerGenerations.delete(producer.pluginId);
+    let removed = false;
+    for (const [upstreamId, entry] of this.entries) {
+      if (entry.producer.pluginId !== producer.pluginId || entry.producer.pluginGeneration !== producer.pluginGeneration) continue;
+      this.entries.delete(upstreamId);
+      removed = true;
+    }
+    if (!removed) return { status: "unchanged", registryRevision: this.revision };
+    this.revision += 1;
+    this.notify();
+    return { status: "revoked", registryRevision: this.revision };
+  }
+  subscribe(listener) {
+    if (this.disposed) throw new Error("Upstream registry generation is stale");
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  }
+  catalog(pluginGeneration) {
+    if (this.disposed || pluginGeneration !== this.pluginGeneration) {
+      return { code: "stale-generation", message: "Catalog generation is stale" };
+    }
+    const active = this.activeEntries();
+    const groups = /* @__PURE__ */ new Map();
+    for (const entry of active) {
+      const descriptor = entry.descriptor;
+      const groupedModels = /* @__PURE__ */ new Map();
+      for (const route of descriptor.models) {
+        if (!route.enabled) continue;
+        groupedModels.set(route.modelId, [...groupedModels.get(route.modelId) ?? [], route]);
+      }
+      const prefix = descriptor.prefix ?? descriptor.upstreamId;
+      const models = [...groupedModels.entries()].sort(([left], [right]) => left.localeCompare(right)).map(
+        ([modelId, routes]) => {
+          const first = routes[0];
+          return {
+            modelId,
+            gatewayModelId: `${prefix}/${modelId}`,
+            displayName: first.displayName ?? modelId,
+            sourceModelIds: routes.map((route) => route.sourceModelId).sort(),
+            isDefault: first.isDefault,
+            inputModalities: normalizedModalities(first.inputModalities)
+          };
+        }
+      );
+      const provider = {
+        providerId: descriptor.upstreamId,
+        displayName: descriptor.displayName,
+        prefix,
+        wireApi: descriptor.wireApi,
+        order: descriptor.order,
+        revision: descriptor.revision,
+        groupId: descriptor.group.groupId,
+        requestTimeoutMs: descriptor.requestTimeoutMs,
+        models
+      };
+      const existing = groups.get(descriptor.group.groupId);
+      groups.set(descriptor.group.groupId, {
+        groupId: descriptor.group.groupId,
+        displayName: descriptor.group.displayName,
+        order: descriptor.group.order,
+        providers: [...existing?.providers ?? [], provider].sort(
+          (left, right) => compareOrderThenId({ order: left.order, id: left.providerId }, { order: right.order, id: right.providerId })
+        )
+      });
+    }
+    const orderedGroups = [...groups.values()].sort(
+      (left, right) => compareOrderThenId({ order: left.order, id: left.groupId }, { order: right.order, id: right.groupId })
+    );
+    const base = {
+      contract: CLI_PROXY_MODEL_CATALOG_CONTRACT_V1,
+      schemaVersion: 1,
+      pluginGeneration: this.pluginGeneration,
+      registryRevision: this.revision,
+      upstreamRevisions: Object.fromEntries(
+        active.map((entry) => [entry.descriptor.upstreamId, entry.descriptor.revision])
+      ),
+      groups: orderedGroups
+    };
+    return { ...base, catalogDigest: digest(base) };
+  }
+  gatewayPlan(pluginGeneration) {
+    const catalog = this.catalog(pluginGeneration);
+    if ("code" in catalog) return catalog;
+    const active = this.activeEntries();
+    const responses = [];
+    const chat = [];
+    const composition = [];
+    for (const entry of active) {
+      const descriptor = entry.descriptor;
+      const prefix = descriptor.prefix ?? descriptor.upstreamId;
+      const routes = descriptor.models.filter((route) => route.enabled).sort(
+        (left, right) => left.modelId.localeCompare(right.modelId) || left.sourceModelId.localeCompare(right.sourceModelId)
+      );
+      if (descriptor.wireApi === "responses") {
+        const index2 = responses.length;
+        responses.push({
+          "api-key": null,
+          prefix,
+          "base-url": null,
+          "request-retry": 0,
+          models: routes.map((route) => ({
+            name: route.sourceModelId,
+            alias: route.modelId,
+            "display-name": route.displayName ?? route.modelId,
+            "force-mapping": true
+          }))
+        });
+        composition.push({
+          upstreamId: descriptor.upstreamId,
+          source: entry.source,
+          origin: {
+            slot: `upstream-${descriptor.upstreamId}-origin`,
+            targetPointer: `/codex-api-key/${index2}/base-url`
+          },
+          authorization: {
+            slot: `upstream-${descriptor.upstreamId}-authorization`,
+            targetPointer: `/codex-api-key/${index2}/api-key`
+          }
+        });
+        continue;
+      }
+      const index = chat.length;
+      chat.push({
+        name: descriptor.upstreamId,
+        disabled: false,
+        prefix,
+        "base-url": null,
+        "api-key-entries": [{ "api-key": null }],
+        "request-retry": 0,
+        models: routes.map((route) => ({
+          name: route.sourceModelId,
+          alias: route.modelId,
+          "display-name": route.displayName ?? route.modelId,
+          "force-mapping": true,
+          ...route.inputModalities === void 0 ? {} : { "input-modalities": normalizedModalities(route.inputModalities) }
+        }))
+      });
+      composition.push({
+        upstreamId: descriptor.upstreamId,
+        source: entry.source,
+        origin: {
+          slot: `upstream-${descriptor.upstreamId}-origin`,
+          targetPointer: `/openai-compatibility/${index}/base-url`
+        },
+        authorization: {
+          slot: `upstream-${descriptor.upstreamId}-authorization`,
+          targetPointer: `/openai-compatibility/${index}/api-key-entries/0/api-key`
+        }
+      });
+    }
+    return {
+      contract: CLI_PROXY_GATEWAY_PLAN_CONTRACT_V1,
+      schemaVersion: 1,
+      pluginGeneration: this.pluginGeneration,
+      registryRevision: this.revision,
+      catalogDigest: catalog.catalogDigest,
+      configuration: {
+        "codex-api-key": responses,
+        "openai-compatibility": chat
+      },
+      composition
+    };
+  }
+  dispose() {
+    if (this.disposed) return;
+    this.disposed = true;
+    this.entries.clear();
+    this.producerGenerations.clear();
+    this.listeners.clear();
+    this.revision += 1;
+  }
+  notify() {
+    for (const listener of this.listeners) listener(this.revision);
+  }
+  activeEntries() {
+    return [...this.entries.values()].filter((entry) => entry.descriptor.enabled).sort(
+      (left, right) => compareOrderThenId(
+        { order: left.descriptor.group.order, id: left.descriptor.group.groupId },
+        { order: right.descriptor.group.order, id: right.descriptor.group.groupId }
+      ) || compareOrderThenId(
+        { order: left.descriptor.order, id: left.descriptor.upstreamId },
+        { order: right.descriptor.order, id: right.descriptor.upstreamId }
+      )
+    );
+  }
+  generationFailure(registryGeneration, producer) {
+    if (!this.disposed && registryGeneration === this.pluginGeneration && this.producerGenerations.get(producer.pluginId) === producer.pluginGeneration) return void 0;
+    return {
+      status: "stale-generation",
+      diagnostic: { code: "stale-generation", message: "Upstream producer generation is stale" }
+    };
+  }
+};
+function createCliProxyUpstreamRegistrarV1(registry, producer) {
+  const authority = Object.freeze({ ...producer });
+  registry.activateProducer(authority, registry.pluginGeneration);
+  return Object.freeze({
+    producer: authority,
+    register: (registration) => registry.register(registration, registry.pluginGeneration, authority),
+    revoke: (input) => registry.revoke(input, registry.pluginGeneration, authority),
+    dispose: () => registry.disposeProducer(authority, registry.pluginGeneration)
+  });
+}
+
+// src/service/upstream-context.ts
+function sourceKey(source) {
+  return JSON.stringify([source.source, source.pluginId, source.serviceId]);
+}
+function createCliProxyUpstreamContextProviderV1() {
+  return Object.freeze({
+    service: CLI_PROXY_UPSTREAM_REGISTRY_SERVICE_V1,
+    create: ({ target, signal }) => {
+      const registry = new CliProxyUpstreamRegistryV1(
+        target.pluginGeneration,
+        sourceKey
+      );
+      const bindings = /* @__PURE__ */ new Set();
+      let disposed = false;
+      const dispose = () => {
+        if (disposed) return;
+        disposed = true;
+        for (const binding of [...bindings]) binding.dispose();
+        bindings.clear();
+        registry.dispose();
+      };
+      signal.addEventListener("abort", dispose, { once: true });
+      return Object.freeze({
+        providerValue: registry,
+        bind: ({ producer, target: bindingTarget, signal: bindingSignal }) => {
+          if (disposed || bindingSignal.aborted || bindingTarget.pluginId !== target.pluginId || bindingTarget.pluginGeneration !== target.pluginGeneration || bindingTarget.serviceId !== target.serviceId || bindingTarget.serviceGeneration !== target.serviceGeneration) throw new Error("CLIProxyAPI upstream context generation is stale");
+          const registrar = createCliProxyUpstreamRegistrarV1(registry, producer);
+          let bindingDisposed = false;
+          const binding = Object.freeze({
+            value: registrar,
+            dispose: () => {
+              if (bindingDisposed) return;
+              bindingDisposed = true;
+              bindings.delete(binding);
+              registrar.dispose();
+            }
+          });
+          bindings.add(binding);
+          bindingSignal.addEventListener("abort", () => binding.dispose(), { once: true });
+          return binding;
+        },
+        dispose
+      });
+    }
+  });
+}
+
+// src/service/gateway.ts
+var contextServices = Object.freeze([
+  createCliProxyUpstreamContextProviderV1()
+]);
+var CLI_PROXY_NATIVE_PROVIDER_ID = "cli-proxy-api";
+function activationError(stage, result) {
+  return new Error(`CLIProxyAPI ${stage} failed: ${result.diagnostic?.code ?? result.status}`);
+}
+function assertPlan(value) {
+  if ("code" in value) throw new Error(`CLIProxyAPI gateway plan failed: ${value.code}`);
+}
+function modelIds(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) return /* @__PURE__ */ new Set();
+  const data = value.data;
+  if (!Array.isArray(data)) return /* @__PURE__ */ new Set();
+  return new Set(data.flatMap((item) => {
+    if (item === null || typeof item !== "object" || Array.isArray(item)) return [];
+    return typeof item.id === "string" ? [item.id] : [];
+  }));
+}
+function expectedSourceModels(catalog, upstreamId) {
+  for (const group of catalog.groups) {
+    const provider = group.providers.find((item) => item.providerId === upstreamId);
+    if (provider !== void 0) return provider.models.flatMap((model) => model.sourceModelIds);
+  }
+  return [];
+}
+function compareUtf8Json(left, right) {
+  return Buffer.compare(Buffer.from(JSON.stringify(left)), Buffer.from(JSON.stringify(right)));
+}
+function nativeProviderCatalog(models) {
+  const routes = [...models].map((model) => ({ alias: model, gatewayModelId: model })).sort((left, right) => compareUtf8Json([left.alias], [right.alias]));
+  const defaultAlias = routes[0]?.alias;
+  if (defaultAlias === void 0) return void 0;
+  const generation = `sha256:${createHash4("sha256").update(JSON.stringify(routes.map((route) => route.gatewayModelId))).digest("hex")}`;
+  const digest2 = `sha256:${createHash4("sha256").update(
+    JSON.stringify([generation, defaultAlias, routes.map((route) => [route.alias, route.gatewayModelId])])
+  ).digest("hex")}`;
+  return { generation, digest: digest2, defaultAlias, routes };
+}
+function relativePointer(collection, pointer) {
+  const prefix = `/${collection}`;
+  if (!pointer.startsWith(`${prefix}/`)) throw new Error("CLIProxyAPI gateway plan contains an invalid pointer");
+  return pointer.slice(prefix.length);
+}
+async function activateCliProxyGateway(context, input) {
+  const registry = context.cliProxyUpstreams;
+  let active;
+  let transition = Promise.resolve();
+  let unsubscribe = () => void 0;
+  let disposePromise;
+  let gatewayHandle;
+  let publication;
+  let publicationDigest;
+  const authorization = /* @__PURE__ */ new Map();
+  let activeRevision;
+  let scheduleModelRefresh = async () => void 0;
+  const uiState = {
+    pluginGeneration: input.owner.pluginGeneration,
+    registry,
+    authorization,
+    get activeRevision() {
+      return activeRevision;
+    },
+    set activeRevision(value) {
+      activeRevision = value;
+    },
+    refreshGatewayModels: () => scheduleModelRefresh()
+  };
+  const unbindGatewayUIState = bindGatewayUIState(uiState);
+  const activate = async (catalog, plan) => {
+    gatewayHandle ??= await context.managedServices.register(cliProxyGatewayDefinition, {
+      revision: plan.catalogDigest
+    });
+    const handle = gatewayHandle;
+    const leases = [];
+    let cleanupPromise;
+    const cleanup = () => {
+      cleanupPromise ??= (async () => {
+        const failures = [];
+        const attempt = async (operation) => {
+          try {
+            await operation();
+          } catch (error) {
+            failures.push(error);
+          }
+        };
+        for (const lease of leases.splice(0).reverse()) {
+          await attempt(() => input.client.release(lease));
+        }
+        if (failures.length > 0) {
+          throw new AggregateError(failures, "CLIProxyAPI managed gateway cleanup failed");
+        }
+      })();
+      return cleanupPromise;
+    };
+    try {
+      const sources = [];
+      authorization.clear();
+      for (const composition of plan.composition) {
+        const acquired = await input.client.acquire(composition.source, { signal: input.signal });
+        if (acquired.status !== "ready") throw activationError(`${composition.upstreamId} acquisition`, acquired);
+        leases.push(acquired.lease);
+        sources.push({ source: composition.upstreamId, lease: acquired.lease });
+        authorization.set(composition.upstreamId, acquired.projection.httpAuthorization.state === "configured");
+        const discovered = await input.client.invoke(acquired.lease, "models.list", void 0, { signal: input.signal });
+        if (discovered.status !== "accepted") {
+          throw activationError(`${composition.upstreamId} model validation`, discovered);
+        }
+        const actual = modelIds(discovered.value);
+        const missing = expectedSourceModels(catalog, composition.upstreamId).filter((model) => !actual.has(model));
+        if (missing.length > 0) {
+          throw new Error(
+            `CLIProxyAPI upstream ${composition.upstreamId} omitted declared models: ${missing.join(", ")}`
+          );
+        }
+      }
+      const bindings = [
+        {
+          targetSlot: "codex-upstreams",
+          source: { kind: "safe-literal", value: plan.configuration["codex-api-key"] }
+        },
+        {
+          targetSlot: "openai-upstreams",
+          source: { kind: "safe-literal", value: plan.configuration["openai-compatibility"] }
+        }
+      ];
+      for (const composition of plan.composition) {
+        const collection = composition.origin.targetPointer.startsWith("/codex-api-key/") ? "codex-api-key" : "openai-compatibility";
+        bindings.push({
+          targetSlot: collection === "codex-api-key" ? "codex-upstreams" : "openai-upstreams",
+          targetPointer: relativePointer(collection, composition.origin.targetPointer),
+          source: { kind: "source-origin", source: composition.upstreamId, origin: "api" }
+        });
+        if (authorization.get(composition.upstreamId)) {
+          bindings.push({
+            targetSlot: collection === "codex-api-key" ? "codex-upstreams" : "openai-upstreams",
+            targetPointer: relativePointer(collection, composition.authorization.targetPointer),
+            source: { kind: "source-authorization", source: composition.upstreamId }
+          });
+        }
+      }
+      const materialized = await input.client.materialize({
+        target: handle.binding,
+        revision: plan.catalogDigest,
+        sources,
+        bindings
+      }, { signal: input.signal });
+      if (materialized.status !== "accepted") throw activationError("materialization", materialized);
+      const ready = await handle.ensureReady({
+        materialization: {
+          materializationHandle: materialized.materializationHandle,
+          revision: materialized.revision
+        },
+        signal: input.signal
+      });
+      if (ready.status !== "ready") throw activationError("readiness", ready);
+      const actualGatewayModels = await readGatewayModels();
+      const expectedGatewayModels = catalog.groups.flatMap(
+        (group) => group.providers.flatMap((provider) => provider.models.map((model) => model.gatewayModelId))
+      );
+      const missingGatewayModels = expectedGatewayModels.filter((model) => !actualGatewayModels.has(model));
+      if (missingGatewayModels.length > 0) {
+        throw new Error(`CLIProxyAPI gateway omitted composed models: ${missingGatewayModels.join(", ")}`);
+      }
+      await publishGatewayModels(actualGatewayModels);
+      activeRevision = catalog.registryRevision;
+      return cleanup;
+    } catch (error) {
+      try {
+        await cleanup();
+      } catch (cleanupError) {
+        const cleanupFailures = cleanupError instanceof AggregateError ? cleanupError.errors : [cleanupError];
+        throw new AggregateError(
+          [error, ...cleanupFailures],
+          "CLIProxyAPI managed gateway activation and cleanup failed",
+          { cause: error }
+        );
+      }
+      throw error;
+    }
+  };
+  const disposePublication = async () => {
+    if (publication === void 0) return;
+    const current = publication;
+    publication = void 0;
+    publicationDigest = void 0;
+    const result = await current.dispose();
+    const alreadyRevoked = result.status === "stale" && (result.diagnostic.code === "disposed" || result.diagnostic.code === "stale-generation");
+    if (result.status !== "disposed" && !alreadyRevoked) {
+      throw activationError("native publication cleanup", result);
+    }
+  };
+  const readGatewayModels = async () => {
+    if (gatewayHandle === void 0) throw new Error("CLIProxyAPI gateway is not registered");
+    const acquired = await input.client.acquire(gatewayHandle.binding.identity, { signal: input.signal });
+    if (acquired.status !== "ready") throw activationError("validation acquisition", acquired);
+    try {
+      const verified = await input.client.invoke(acquired.lease, "gateway.models.list", void 0, {
+        signal: input.signal
+      });
+      if (verified.status !== "accepted") throw activationError("model validation", verified);
+      return modelIds(verified.value);
+    } finally {
+      input.client.release(acquired.lease);
+    }
+  };
+  const publishGatewayModels = async (models) => {
+    if (gatewayHandle === void 0) throw new Error("CLIProxyAPI gateway is not registered");
+    const catalog = nativeProviderCatalog(models);
+    if (catalog?.digest === publicationDigest) return;
+    await disposePublication();
+    if (catalog === void 0 || input.signal.aborted) return;
+    const published = await gatewayHandle.publishNativeProvider({
+      providerId: CLI_PROXY_NATIVE_PROVIDER_ID,
+      compositionOrigin: "api",
+      catalog
+    }, { signal: input.signal });
+    if (published.status !== "accepted") throw activationError("cli-proxy-api native publication", published);
+    publication = published.publication;
+    publicationDigest = catalog.digest;
+  };
+  const reconcile = async () => {
+    if (input.signal.aborted) return;
+    const catalog = registry.catalog(input.owner.pluginGeneration);
+    if ("code" in catalog) throw new Error(`CLIProxyAPI catalog failed: ${catalog.code}`);
+    if (active?.revision === catalog.registryRevision) return;
+    const previous = active;
+    active = void 0;
+    activeRevision = void 0;
+    await previous?.dispose();
+    const plan = registry.gatewayPlan(input.owner.pluginGeneration);
+    assertPlan(plan);
+    if (gatewayHandle === void 0) {
+      gatewayHandle = await context.managedServices.register(cliProxyGatewayDefinition, {
+        revision: plan.catalogDigest
+      });
+    }
+    if (input.signal.aborted) return;
+    const cleanup = await activate(catalog, plan);
+    if (input.signal.aborted) {
+      await cleanup();
+      return;
+    }
+    active = { revision: catalog.registryRevision, dispose: cleanup };
+  };
+  const schedule = () => {
+    const pending = transition.then(reconcile);
+    transition = pending.catch(() => void 0);
+    return pending;
+  };
+  scheduleModelRefresh = () => {
+    const pending = transition.then(async () => {
+      if (input.signal.aborted || active === void 0) return;
+      await publishGatewayModels(await readGatewayModels());
+    });
+    transition = pending.catch(() => void 0);
+    return pending;
+  };
+  const dispose = () => {
+    if (disposePromise !== void 0) return disposePromise;
+    disposePromise = (async () => {
+      unsubscribe();
+      unbindGatewayUIState();
+      await transition;
+      const failures = [];
+      const cleanup = async (operation) => {
+        try {
+          await operation();
+        } catch (error) {
+          failures.push(...error instanceof AggregateError ? error.errors : [error]);
+        }
+      };
+      const current = active;
+      active = void 0;
+      if (current !== void 0) await cleanup(current.dispose);
+      await cleanup(disposePublication);
+      if (gatewayHandle !== void 0) {
+        const handle = gatewayHandle;
+        gatewayHandle = void 0;
+        await cleanup(() => handle.dispose());
+      }
+      await cleanup(() => input.client.dispose());
+      if (failures.length > 0) {
+        throw new AggregateError(failures, "CLIProxyAPI managed gateway cleanup failed");
+      }
+    })();
+    return disposePromise;
+  };
+  try {
+    unsubscribe = registry.subscribe(() => {
+      void schedule().catch(() => void 0);
+    });
+    const onAbort = () => {
+      void dispose().catch(() => void 0);
+    };
+    input.signal.addEventListener("abort", onAbort, { once: true });
+    context.effect(() => () => {
+      input.signal.removeEventListener("abort", onAbort);
+      return dispose();
+    }, "CLIProxyAPI managed gateway");
+    await schedule();
+    if (input.signal.aborted) await dispose();
+  } catch (error) {
+    try {
+      await dispose();
+    } catch (cleanupError) {
+      const activationFailures = error instanceof AggregateError ? error.errors : [error];
+      const activationCause = error instanceof AggregateError && error.cause !== void 0 ? error.cause : error;
+      const cleanupFailures = cleanupError instanceof AggregateError ? cleanupError.errors : [cleanupError];
+      throw new AggregateError(
+        [...activationFailures, ...cleanupFailures],
+        "CLIProxyAPI managed gateway activation and cleanup failed",
+        { cause: activationCause }
+      );
+    }
+    throw error;
+  }
+}
+var gatewayApply = async (context, input) => {
+  await activateCliProxyGateway(context, input);
+};
+var apply = Object.assign(gatewayApply, {
+  inject: ["managedServices", CLI_PROXY_UPSTREAM_REGISTRY_SERVICE_V1]
+});
+export {
+  CLI_PROXY_GATEWAY_CODEX_UPSTREAMS_SCHEMA_V1,
+  CLI_PROXY_GATEWAY_MANAGEMENT_V1,
+  CLI_PROXY_GATEWAY_MODEL_CATALOG_SCHEMA_V1,
+  CLI_PROXY_GATEWAY_OPENAI_UPSTREAMS_SCHEMA_V1,
+  CLI_PROXY_GATEWAY_PLAN_CONTRACT_V1,
+  CLI_PROXY_GATEWAY_SERVICE_ID,
+  CLI_PROXY_MODEL_CATALOG_CONTRACT_V1,
+  CLI_PROXY_NATIVE_PROVIDER_ID,
+  CLI_PROXY_UPSTREAM_DESCRIPTOR_CONTRACT_V1,
+  CLI_PROXY_UPSTREAM_DESCRIPTOR_SCHEMA_V1,
+  CLI_PROXY_UPSTREAM_REGISTRY_SERVICE_V1,
+  CliProxyUpstreamRegistryV1,
+  activateCliProxyGateway,
+  apply,
+  cliProxyGatewayDefinition,
+  cliProxyGatewayDefinitionRevision,
+  contextServices,
+  createCliProxyUpstreamRegistrarV1,
+  managedServiceUI
+};