cordisx 0.1.0-beta.21 → 0.1.0-beta.23

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

@@ -1,11 +1,12 @@
 // src/service/gateway.ts
-import { createHash as createHash4 } from "node:crypto";
+import { createHash as createHash5 } 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_GATEWAY_EXTENSION_PLAN_SCHEMA_V1 = "https://raw.githubusercontent.com/cordisx/plugin-cli-proxy-api/main/schemas/cli-proxy-gateway-extension-plan.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";
@@ -62,6 +63,13 @@ var cliProxyGatewayDefinition = {
       target: "configuration",
       pointer: "/openai-compatibility",
       valueSchema: CLI_PROXY_GATEWAY_OPENAI_UPSTREAMS_SCHEMA_V1
+    },
+    {
+      slot: "gateway-extensions",
+      source: "composition",
+      target: "configuration",
+      pointer: "/plugins/configs/cordisx-gateway-bridge",
+      valueSchema: CLI_PROXY_GATEWAY_EXTENSION_PLAN_SCHEMA_V1
     }
   ],
   authentication: { mode: "none" },
@@ -161,8 +169,8 @@ function providerId(value) {
   return `custom:${safe}`;
 }
 function revision(value) {
-  const digest2 = createHash2("sha256").update(JSON.stringify(value)).digest("hex").slice(0, 12);
-  return Number.parseInt(digest2, 16);
+  const digest3 = createHash2("sha256").update(JSON.stringify(value)).digest("hex").slice(0, 12);
+  return Number.parseInt(digest3, 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;
@@ -482,21 +490,486 @@ var managedServiceUI = Object.freeze({
   }
 });
 
-// src/service/upstream-registry.ts
+// src/service/extension-registry.ts
 import { createHash as createHash3 } from "node:crypto";
+var CLI_PROXY_GATEWAY_ADAPTER_SCHEMA_V1 = "https://raw.githubusercontent.com/cordisx/plugin-cli-proxy-api/main/schemas/cli-proxy-gateway-adapter.v1.schema.json";
+var CLI_PROXY_GATEWAY_CONNECTION_SCHEMA_V1 = "https://raw.githubusercontent.com/cordisx/plugin-cli-proxy-api/main/schemas/cli-proxy-gateway-connection.v1.schema.json";
+var CLI_PROXY_GATEWAY_ADAPTER_CONTRACT_V1 = "cordisx.cli-proxy-gateway-adapter/v1";
+var CLI_PROXY_GATEWAY_CONNECTION_CONTRACT_V1 = "cordisx.cli-proxy-gateway-connection/v1";
+var CLI_PROXY_GATEWAY_EXTENSION_PLAN_CONTRACT_V1 = "cordisx.cli-proxy-gateway-extension-plan/v1";
+var CLI_PROXY_GATEWAY_EXTENSION_REGISTRY_SERVICE_V1 = "cliProxyGatewayExtensions";
+var ID_PATTERN = /^[a-z0-9][a-z0-9._-]{0,95}$/;
+var HEADER_PATTERN = /^[!#$%&'*+.^_`|~0-9A-Za-z-]{1,128}$/;
+var POINTER_PATTERN = /^(?:\/(?:[^~/]|~0|~1)*)+$/;
+var MAX_ADAPTERS = 64;
+var MAX_CONNECTIONS = 128;
+var MAX_MODELS = 256;
+function isText(value, maximum) {
+  return value.length > 0 && value.length <= maximum && value === value.trim() && !/[\u0000-\u001f\u007f]/.test(value);
+}
+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")}`;
+}
+function rejection(failure) {
+  return { status: "rejected", diagnostic: failure };
+}
+function validRevision(value) {
+  return Number.isSafeInteger(value) && value > 0;
+}
+function validTemplate(value, depth = 0) {
+  if (depth > 12) return false;
+  if (value === null || typeof value === "boolean") return true;
+  if (typeof value === "number") return Number.isFinite(value);
+  if (typeof value === "string") return value.length <= 8192 && !value.includes("\0");
+  if (Array.isArray(value)) return value.length <= 128 && value.every((item) => validTemplate(item, depth + 1));
+  const entries = Object.entries(value);
+  return entries.length <= 128 && entries.every(([key, item]) => isText(key, 256) && validTemplate(item, depth + 1));
+}
+function validateAdapter(adapter) {
+  if (adapter.$schema !== CLI_PROXY_GATEWAY_ADAPTER_SCHEMA_V1 || adapter.contract !== CLI_PROXY_GATEWAY_ADAPTER_CONTRACT_V1 || adapter.schemaVersion !== 1) return { code: "invalid-registration", field: "contract", message: "Unsupported gateway adapter contract" };
+  if (!ID_PATTERN.test(adapter.adapterId)) {
+    return { code: "invalid-registration", field: "adapterId", message: "Invalid adapter id" };
+  }
+  if (!validRevision(adapter.revision)) {
+    return { code: "invalid-registration", field: "revision", message: "Revision must be a positive safe integer" };
+  }
+  if (adapter.sessionSources.length > 16) {
+    return { code: "invalid-registration", field: "sessionSources", message: "Too many session sources" };
+  }
+  for (const source of adapter.sessionSources) {
+    if (source.kind === "header" ? !HEADER_PATTERN.test(source.name) : !POINTER_PATTERN.test(source.pointer) || source.pointer.length > 512) return { code: "invalid-registration", field: "sessionSources", message: "Invalid session source" };
+  }
+  for (const name of adapter.request.clearHeaders ?? []) {
+    if (!HEADER_PATTERN.test(name)) {
+      return { code: "invalid-registration", field: "request.clearHeaders", message: "Invalid header name" };
+    }
+  }
+  for (const [name, value] of Object.entries(adapter.request.setHeaders ?? {})) {
+    if (!HEADER_PATTERN.test(name) || !validTemplate(value)) {
+      return { code: "invalid-registration", field: "request.setHeaders", message: "Invalid header transform" };
+    }
+  }
+  for (const [pointer, value] of Object.entries(adapter.request.setBody ?? {})) {
+    if (!POINTER_PATTERN.test(pointer) || pointer.length > 512 || !validTemplate(value)) {
+      return { code: "invalid-registration", field: "request.setBody", message: "Invalid body transform" };
+    }
+  }
+  if (stableStringify(adapter).length > 64 * 1024) {
+    return { code: "invalid-registration", message: "Adapter exceeds the supported size" };
+  }
+  return void 0;
+}
+function validateConnection(connection) {
+  if (connection.$schema !== CLI_PROXY_GATEWAY_CONNECTION_SCHEMA_V1 || connection.contract !== CLI_PROXY_GATEWAY_CONNECTION_CONTRACT_V1 || connection.schemaVersion !== 1) return { code: "invalid-registration", field: "contract", message: "Unsupported gateway connection contract" };
+  if (!ID_PATTERN.test(connection.connectionId)) {
+    return { code: "invalid-registration", field: "connectionId", message: "Invalid connection id" };
+  }
+  if (!validRevision(connection.revision)) {
+    return { code: "invalid-registration", field: "revision", message: "Revision must be a positive safe integer" };
+  }
+  if (connection.wireApi !== "responses" && connection.wireApi !== "chat-completions") {
+    return { code: "invalid-registration", field: "wireApi", message: "Unsupported wire API" };
+  }
+  if (!connection.endpointPath.startsWith("/") || connection.endpointPath.startsWith("//") || connection.endpointPath.length > 512 || /[?#\u0000-\u001f\u007f]/.test(connection.endpointPath)) return { code: "invalid-registration", field: "endpointPath", message: "Invalid endpoint path" };
+  if (!ID_PATTERN.test(connection.adapter.adapterId) || !validRevision(connection.adapter.revision)) {
+    return { code: "invalid-registration", field: "adapter", message: "Invalid adapter reference" };
+  }
+  if (connection.models.length === 0 || connection.models.length > MAX_MODELS) {
+    return { code: "invalid-registration", field: "models", message: "Model routes are outside the supported range" };
+  }
+  const gatewayModels = /* @__PURE__ */ new Set();
+  const sourceModels = /* @__PURE__ */ new Set();
+  let defaults = 0;
+  for (const model of connection.models) {
+    if (!isText(model.sourceModelId, 256) || !isText(model.modelId, 256) || model.modelId.includes("/")) {
+      return { code: "invalid-registration", field: "models", message: "Invalid model identity" };
+    }
+    if (model.displayName !== void 0 && !isText(model.displayName, 200)) {
+      return { code: "invalid-registration", field: "models.displayName", message: "Invalid model display name" };
+    }
+    if (gatewayModels.has(model.modelId) || sourceModels.has(model.sourceModelId)) {
+      return { code: "conflicting-model", field: "models", message: "Duplicate connection model route" };
+    }
+    gatewayModels.add(model.modelId);
+    sourceModels.add(model.sourceModelId);
+    if (model.enabled && model.isDefault) defaults += 1;
+  }
+  if (!connection.models.some((model) => model.enabled)) {
+    return { code: "invalid-registration", field: "models", message: "At least one enabled model route is required" };
+  }
+  if (defaults > 1) {
+    return { code: "conflicting-model", field: "models.isDefault", message: "Only one default model is allowed" };
+  }
+  return void 0;
+}
+var CliProxyGatewayExtensionRegistryV1 = class {
+  constructor(pluginGeneration, sourceKey3) {
+    this.pluginGeneration = pluginGeneration;
+    this.sourceKey = sourceKey3;
+    if (!isText(pluginGeneration, 256)) throw new Error("Invalid plugin generation");
+  }
+  pluginGeneration;
+  sourceKey;
+  adapters = /* @__PURE__ */ new Map();
+  connections = /* @__PURE__ */ new Map();
+  producerGenerations = /* @__PURE__ */ new Map();
+  listeners = /* @__PURE__ */ new Set();
+  revision = 0;
+  disposed = false;
+  activateProducer(producer, registryGeneration) {
+    if (this.disposed || registryGeneration !== this.pluginGeneration) {
+      throw new Error("Gateway extension registry generation is stale");
+    }
+    if (!ID_PATTERN.test(producer.pluginId) || !isText(producer.pluginGeneration, 256)) {
+      throw new Error("Invalid gateway extension producer authority");
+    }
+    if (this.producerGenerations.get(producer.pluginId) === producer.pluginGeneration) return;
+    this.producerGenerations.set(producer.pluginId, producer.pluginGeneration);
+    if (this.removeProducerEntries(producer.pluginId)) this.changed();
+  }
+  registerAdapter(adapter, registryGeneration, producer) {
+    const generationFailure = this.generationFailure(registryGeneration, producer);
+    if (generationFailure !== void 0) return generationFailure;
+    const validation = validateAdapter(adapter);
+    if (validation !== void 0) return rejection(validation);
+    const current = this.adapters.get(adapter.adapterId);
+    const ownership = this.ownershipFailure(current?.producer, producer);
+    if (ownership !== void 0) return ownership;
+    if (current !== void 0) {
+      const revision2 = this.revisionResult(current.adapter.revision, adapter.revision, current.adapter, adapter);
+      if (revision2 !== void 0) return revision2;
+    } else if (this.adapters.size >= MAX_ADAPTERS) {
+      return rejection({ code: "capacity-exceeded", message: "Gateway adapter capacity was reached" });
+    }
+    this.adapters.set(adapter.adapterId, { producer, adapter: structuredClone(adapter) });
+    this.changed();
+    return { status: current === void 0 ? "registered" : "updated", registryRevision: this.revision };
+  }
+  registerConnection(connection, registryGeneration, producer) {
+    const generationFailure = this.generationFailure(registryGeneration, producer);
+    if (generationFailure !== void 0) return generationFailure;
+    const validation = validateConnection(connection);
+    if (validation !== void 0) return rejection(validation);
+    const current = this.connections.get(connection.connectionId);
+    const ownership = this.ownershipFailure(current?.producer, producer);
+    if (ownership !== void 0) return ownership;
+    const sourceKey3 = this.sourceKey(connection.source);
+    if (!isText(sourceKey3, 512)) {
+      return rejection({
+        code: "invalid-registration",
+        field: "source",
+        message: "Invalid connection source reference"
+      });
+    }
+    if (current !== void 0) {
+      const revision2 = this.revisionResult(
+        current.connection.revision,
+        connection.revision,
+        { ...current.connection, source: current.sourceKey },
+        { ...connection, source: sourceKey3 }
+      );
+      if (revision2 !== void 0) return revision2;
+    } else if (this.connections.size >= MAX_CONNECTIONS) {
+      return rejection({ code: "capacity-exceeded", message: "Gateway connection capacity was reached" });
+    }
+    for (const [connectionId, entry] of this.connections) {
+      if (connectionId === connection.connectionId) continue;
+      if (entry.sourceKey === sourceKey3) {
+        return rejection({
+          code: "conflicting-source",
+          field: "source",
+          message: "Connection source is already registered"
+        });
+      }
+      const existingModels = new Set(
+        entry.connection.models.filter((model) => entry.connection.enabled && model.enabled).map(
+          (model) => `${entry.connection.connectionId}/${model.modelId}`
+        )
+      );
+      if (connection.models.some(
+        (model) => connection.enabled && model.enabled && existingModels.has(
+          `${connection.connectionId}/${model.modelId}`
+        )
+      )) return rejection({ code: "conflicting-model", field: "models", message: "Gateway model is already registered" });
+    }
+    this.connections.set(connection.connectionId, {
+      producer,
+      sourceKey: sourceKey3,
+      connection: structuredClone(connection)
+    });
+    this.changed();
+    return { status: current === void 0 ? "registered" : "updated", registryRevision: this.revision };
+  }
+  revokeAdapter(input, registryGeneration, producer) {
+    const generationFailure = this.generationFailure(registryGeneration, producer);
+    if (generationFailure !== void 0) return generationFailure;
+    const current = this.adapters.get(input.adapterId);
+    if (current === void 0) {
+      return rejection({ code: "not-found", field: "adapterId", message: "Adapter is not registered" });
+    }
+    const ownership = this.ownershipFailure(current.producer, producer);
+    if (ownership !== void 0) return ownership;
+    if (current.adapter.revision !== input.expectedRevision) {
+      return rejection({ code: "stale-revision", field: "expectedRevision", message: "Adapter revision is stale" });
+    }
+    this.adapters.delete(input.adapterId);
+    this.changed();
+    return { status: "revoked", registryRevision: this.revision };
+  }
+  revokeConnection(input, registryGeneration, producer) {
+    const generationFailure = this.generationFailure(registryGeneration, producer);
+    if (generationFailure !== void 0) return generationFailure;
+    const current = this.connections.get(input.connectionId);
+    if (current === void 0) {
+      return rejection({ code: "not-found", field: "connectionId", message: "Connection is not registered" });
+    }
+    const ownership = this.ownershipFailure(current.producer, producer);
+    if (ownership !== void 0) return ownership;
+    if (current.connection.revision !== input.expectedRevision) {
+      return rejection({ code: "stale-revision", field: "expectedRevision", message: "Connection revision is stale" });
+    }
+    this.connections.delete(input.connectionId);
+    this.changed();
+    return { status: "revoked", registryRevision: this.revision };
+  }
+  disposeProducer(producer, registryGeneration) {
+    const generationFailure = this.generationFailure(registryGeneration, producer);
+    if (generationFailure !== void 0) return generationFailure;
+    this.producerGenerations.delete(producer.pluginId);
+    if (!this.removeProducerEntries(producer.pluginId, producer.pluginGeneration)) {
+      return { status: "unchanged", registryRevision: this.revision };
+    }
+    this.changed();
+    return { status: "revoked", registryRevision: this.revision };
+  }
+  subscribe(listener) {
+    if (this.disposed) throw new Error("Gateway extension registry generation is stale");
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  }
+  plan(pluginGeneration) {
+    if (this.disposed || pluginGeneration !== this.pluginGeneration) {
+      return { code: "stale-generation", message: "Gateway extension plan generation is stale" };
+    }
+    const adapters = [...this.adapters.values()].map((entry) => structuredClone(entry.adapter)).sort(
+      (left, right) => left.adapterId.localeCompare(right.adapterId)
+    );
+    const connections = [];
+    const composition = [];
+    for (const entry of [...this.connections.values()].sort(
+      (left, right) => left.connection.connectionId.localeCompare(right.connection.connectionId)
+    )) {
+      const connection = entry.connection;
+      const adapter = this.adapters.get(connection.adapter.adapterId)?.adapter;
+      const adapterAvailable = adapter?.enabled === true && adapter.revision === connection.adapter.revision;
+      const enabled = connection.enabled && (!connection.adapter.required || adapterAvailable);
+      const index = connections.length;
+      connections.push({
+        connectionId: connection.connectionId,
+        revision: connection.revision,
+        enabled,
+        adapterId: connection.adapter.adapterId,
+        adapterRevision: connection.adapter.revision,
+        adapterRequired: connection.adapter.required,
+        adapterAvailable,
+        wireApi: connection.wireApi,
+        endpointPath: connection.endpointPath,
+        endpoint: null,
+        authorization: connection.authorization,
+        credential: null,
+        models: connection.models.filter((model) => model.enabled).sort(
+          (left, right) => left.modelId.localeCompare(right.modelId)
+        ).map((model) => ({
+          sourceModelId: model.sourceModelId,
+          gatewayModelId: `${connection.connectionId}/${model.modelId}`,
+          displayName: model.displayName ?? model.modelId,
+          isDefault: model.isDefault
+        }))
+      });
+      if (!enabled) continue;
+      const sourceAlias = `extension-${index}`;
+      composition.push({
+        connectionId: connection.connectionId,
+        sourceAlias,
+        source: connection.source,
+        originPointer: `/connections/${index}/endpoint`,
+        ...connection.authorization === "bearer" ? { authorizationPointer: `/connections/${index}/credential` } : {}
+      });
+    }
+    const base = {
+      contract: CLI_PROXY_GATEWAY_EXTENSION_PLAN_CONTRACT_V1,
+      schemaVersion: 1,
+      pluginGeneration: this.pluginGeneration,
+      registryRevision: this.revision,
+      configuration: { adapters, connections },
+      composition
+    };
+    return { ...base, planDigest: digest({ ...base, composition: composition.map(({ source: _, ...item }) => item) }) };
+  }
+  dispose() {
+    if (this.disposed) return;
+    this.disposed = true;
+    this.adapters.clear();
+    this.connections.clear();
+    this.producerGenerations.clear();
+    this.listeners.clear();
+    this.revision += 1;
+  }
+  revisionResult(currentRevision, nextRevision, current, next) {
+    if (nextRevision < currentRevision) {
+      return rejection({ code: "stale-revision", field: "revision", message: "Extension revision is stale" });
+    }
+    if (nextRevision !== currentRevision) return void 0;
+    return stableStringify(current) === stableStringify(next) ? { status: "unchanged", registryRevision: this.revision } : rejection({ code: "stale-revision", field: "revision", message: "Revision was reused with different content" });
+  }
+  ownershipFailure(current, producer) {
+    if (current === void 0) return void 0;
+    if (current.pluginId !== producer.pluginId) {
+      return rejection({ code: "conflicting-producer", message: "Extension is owned by another producer" });
+    }
+    if (current.pluginGeneration !== producer.pluginGeneration) {
+      return {
+        status: "stale-generation",
+        diagnostic: { code: "stale-generation", message: "Extension producer generation is stale" }
+      };
+    }
+    return void 0;
+  }
+  generationFailure(registryGeneration, producer) {
+    if (this.disposed || registryGeneration !== this.pluginGeneration || this.producerGenerations.get(producer.pluginId) !== producer.pluginGeneration) {
+      return {
+        status: "stale-generation",
+        diagnostic: { code: "stale-generation", message: "Gateway extension registry generation is stale" }
+      };
+    }
+    return void 0;
+  }
+  removeProducerEntries(pluginId, pluginGeneration) {
+    let removed = false;
+    for (const [adapterId, entry] of this.adapters) {
+      if (entry.producer.pluginId !== pluginId || pluginGeneration !== void 0 && entry.producer.pluginGeneration !== pluginGeneration) continue;
+      this.adapters.delete(adapterId);
+      removed = true;
+    }
+    for (const [connectionId, entry] of this.connections) {
+      if (entry.producer.pluginId !== pluginId || pluginGeneration !== void 0 && entry.producer.pluginGeneration !== pluginGeneration) continue;
+      this.connections.delete(connectionId);
+      removed = true;
+    }
+    return removed;
+  }
+  changed() {
+    this.revision += 1;
+    for (const listener of this.listeners) listener(this.revision);
+  }
+};
+function createCliProxyGatewayExtensionRegistrarV1(registry, producer) {
+  registry.activateProducer(producer, registry.pluginGeneration);
+  let disposed = false;
+  const currentRevision = () => {
+    const plan = registry.plan(registry.pluginGeneration);
+    return "code" in plan ? 0 : plan.registryRevision;
+  };
+  return Object.freeze({
+    producer,
+    registerAdapter: (adapter) => disposed ? {
+      status: "stale-generation",
+      diagnostic: { code: "stale-generation", message: "Extension registrar is disposed" }
+    } : registry.registerAdapter(adapter, registry.pluginGeneration, producer),
+    revokeAdapter: (input) => disposed ? {
+      status: "stale-generation",
+      diagnostic: { code: "stale-generation", message: "Extension registrar is disposed" }
+    } : registry.revokeAdapter(input, registry.pluginGeneration, producer),
+    registerConnection: (connection) => disposed ? {
+      status: "stale-generation",
+      diagnostic: { code: "stale-generation", message: "Extension registrar is disposed" }
+    } : registry.registerConnection(connection, registry.pluginGeneration, producer),
+    revokeConnection: (input) => disposed ? {
+      status: "stale-generation",
+      diagnostic: { code: "stale-generation", message: "Extension registrar is disposed" }
+    } : registry.revokeConnection(input, registry.pluginGeneration, producer),
+    dispose: () => {
+      if (disposed) return { status: "unchanged", registryRevision: currentRevision() };
+      disposed = true;
+      return registry.disposeProducer(producer, registry.pluginGeneration);
+    }
+  });
+}
+
+// src/service/extension-context.ts
+function sourceKey(source) {
+  return JSON.stringify([source.source, source.pluginId, source.serviceId]);
+}
+function createCliProxyGatewayExtensionContextProviderV1() {
+  return Object.freeze({
+    service: CLI_PROXY_GATEWAY_EXTENSION_REGISTRY_SERVICE_V1,
+    create: ({ target, signal }) => {
+      const registry = new CliProxyGatewayExtensionRegistryV1(
+        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 gateway extension context generation is stale");
+          const registrar = createCliProxyGatewayExtensionRegistrarV1(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/upstream-registry.ts
+import { createHash as createHash4 } 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 ID_PATTERN2 = /^[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_MODELS2 = 256;
 var MAX_REGISTRATIONS = 64;
-function rejection(failure) {
+function rejection2(failure) {
   return { status: "rejected", diagnostic: failure };
 }
-function isText(value, maximum) {
+function isText2(value, maximum) {
   return value.length > 0 && value.length <= maximum && value === value.trim() && !/[\u0000-\u001f\u007f]/.test(value);
 }
 function sameStrings(left, right) {
@@ -509,10 +982,10 @@ 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)) {
+  if (!ID_PATTERN2.test(descriptor.upstreamId)) {
     return { code: "invalid-registration", field: "upstreamId", message: "Invalid upstream id" };
   }
-  if (!isText(descriptor.displayName, 200)) {
+  if (!isText2(descriptor.displayName, 200)) {
     return { code: "invalid-registration", field: "displayName", message: "Invalid upstream display name" };
   }
   if (descriptor.wireApi !== "responses" && descriptor.wireApi !== "chat-completions") {
@@ -531,7 +1004,7 @@ function validateDescriptor(descriptor) {
       message: "Request timeout is outside the supported range"
     };
   }
-  if (!ID_PATTERN.test(descriptor.group.groupId) || !isText(descriptor.group.displayName, 200)) {
+  if (!ID_PATTERN2.test(descriptor.group.groupId) || !isText2(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) {
@@ -541,17 +1014,17 @@ function validateDescriptor(descriptor) {
   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) {
+  if (descriptor.models.length === 0 || descriptor.models.length > MAX_MODELS2) {
     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)) {
+    if (!isText2(route.sourceModelId, 256) || !isText2(route.modelId, 256)) {
       return { code: "invalid-registration", field: "models", message: "Invalid model identity" };
     }
-    if (route.displayName !== void 0 && !isText(route.displayName, 200)) {
+    if (route.displayName !== void 0 && !isText2(route.displayName, 200)) {
       return { code: "invalid-registration", field: "models.displayName", message: "Invalid model display name" };
     }
     if (sourceModels.has(route.sourceModelId)) {
@@ -589,26 +1062,26 @@ function validateDescriptor(descriptor) {
 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);
+function stableValue2(value) {
+  if (Array.isArray(value)) return value.map(stableValue2);
   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)]
+      ([key, item]) => [key, stableValue2(item)]
     )
   );
 }
-function stableStringify(value) {
-  return JSON.stringify(stableValue(value));
+function stableStringify2(value) {
+  return JSON.stringify(stableValue2(value));
 }
-function digest(value) {
-  return `sha256:${createHash3("sha256").update(stableStringify(value)).digest("hex")}`;
+function digest2(value) {
+  return `sha256:${createHash4("sha256").update(stableStringify2(value)).digest("hex")}`;
 }
 var CliProxyUpstreamRegistryV1 = class {
-  constructor(pluginGeneration, sourceKey2) {
+  constructor(pluginGeneration, sourceKey3) {
     this.pluginGeneration = pluginGeneration;
-    this.sourceKey = sourceKey2;
-    if (!isText(pluginGeneration, 256)) throw new Error("Invalid plugin generation");
+    this.sourceKey = sourceKey3;
+    if (!isText2(pluginGeneration, 256)) throw new Error("Invalid plugin generation");
   }
   pluginGeneration;
   sourceKey;
@@ -622,7 +1095,7 @@ var CliProxyUpstreamRegistryV1 = class {
     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({
+      return rejection2({
         code: "conflicting-producer",
         field: "upstreamId",
         message: "Upstream is owned by another producer"
@@ -635,29 +1108,29 @@ var CliProxyUpstreamRegistryV1 = class {
       };
     }
     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 (validation !== void 0) return rejection2(validation);
+    const sourceKey3 = this.sourceKey(registration.source);
+    if (!isText2(sourceKey3, 512)) {
+      return rejection2({ 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" });
+        return rejection2({ 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({
+        return stableStringify2(registration.descriptor) === stableStringify2(current.descriptor) && sourceKey3 === current.sourceKey ? { status: "unchanged", registryRevision: this.revision } : rejection2({
           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" });
+      return rejection2({ 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({
+      if (entry.sourceKey === sourceKey3) {
+        return rejection2({
           code: "conflicting-source",
           field: "source",
           message: "Upstream source is already registered"
@@ -665,20 +1138,20 @@ var CliProxyUpstreamRegistryV1 = class {
       }
       if (entry.descriptor.enabled && registration.descriptor.enabled) {
         if ((entry.descriptor.prefix ?? entry.descriptor.upstreamId) === (registration.descriptor.prefix ?? registration.descriptor.upstreamId)) {
-          return rejection({
+          return rejection2({
             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" });
+          return rejection2({ code: "conflicting-group", field: "group", message: "Group metadata is inconsistent" });
         }
       }
     }
     this.entries.set(registration.descriptor.upstreamId, {
       source: registration.source,
-      sourceKey: sourceKey2,
+      sourceKey: sourceKey3,
       producer,
       descriptor: structuredClone(registration.descriptor)
     });
@@ -691,10 +1164,10 @@ var CliProxyUpstreamRegistryV1 = class {
     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" });
+      return rejection2({ code: "not-found", field: "upstreamId", message: "Upstream is not registered" });
     }
     if (current.producer.pluginId !== producer.pluginId) {
-      return rejection({
+      return rejection2({
         code: "conflicting-producer",
         field: "upstreamId",
         message: "Upstream is owned by another producer"
@@ -707,7 +1180,7 @@ var CliProxyUpstreamRegistryV1 = class {
       };
     }
     if (input.expectedRevision !== current.descriptor.revision) {
-      return rejection({ code: "stale-revision", field: "expectedRevision", message: "Upstream revision is stale" });
+      return rejection2({ code: "stale-revision", field: "expectedRevision", message: "Upstream revision is stale" });
     }
     this.entries.delete(input.upstreamId);
     this.revision += 1;
@@ -718,7 +1191,7 @@ var CliProxyUpstreamRegistryV1 = class {
     if (this.disposed || registryGeneration !== this.pluginGeneration) {
       throw new Error("Upstream registry generation is stale");
     }
-    if (!ID_PATTERN.test(producer.pluginId) || !isText(producer.pluginGeneration, 256)) {
+    if (!ID_PATTERN2.test(producer.pluginId) || !isText2(producer.pluginGeneration, 256)) {
       throw new Error("Invalid upstream producer authority");
     }
     const currentGeneration = this.producerGenerations.get(producer.pluginId);
@@ -816,7 +1289,7 @@ var CliProxyUpstreamRegistryV1 = class {
       ),
       groups: orderedGroups
     };
-    return { ...base, catalogDigest: digest(base) };
+    return { ...base, catalogDigest: digest2(base) };
   }
   gatewayPlan(pluginGeneration) {
     const catalog = this.catalog(pluginGeneration);
@@ -943,7 +1416,7 @@ function createCliProxyUpstreamRegistrarV1(registry, producer) {
 }
 
 // src/service/upstream-context.ts
-function sourceKey(source) {
+function sourceKey2(source) {
   return JSON.stringify([source.source, source.pluginId, source.serviceId]);
 }
 function createCliProxyUpstreamContextProviderV1() {
@@ -952,7 +1425,7 @@ function createCliProxyUpstreamContextProviderV1() {
     create: ({ target, signal }) => {
       const registry = new CliProxyUpstreamRegistryV1(
         target.pluginGeneration,
-        sourceKey
+        sourceKey2
       );
       const bindings = /* @__PURE__ */ new Set();
       let disposed = false;
@@ -991,7 +1464,8 @@ function createCliProxyUpstreamContextProviderV1() {
 
 // src/service/gateway.ts
 var contextServices = Object.freeze([
-  createCliProxyUpstreamContextProviderV1()
+  createCliProxyUpstreamContextProviderV1(),
+  createCliProxyGatewayExtensionContextProviderV1()
 ]);
 var CLI_PROXY_NATIVE_PROVIDER_ID = "cli-proxy-api";
 function activationError(stage, result) {
@@ -1000,6 +1474,15 @@ function activationError(stage, result) {
 function assertPlan(value) {
   if ("code" in value) throw new Error(`CLIProxyAPI gateway plan failed: ${value.code}`);
 }
+function assertExtensionPlan(value) {
+  if ("code" in value) throw new Error(`CLIProxyAPI gateway extension plan failed: ${value.code}`);
+}
+function combinedRevision(upstreamDigest, extensionDigest) {
+  return `sha256:${createHash5("sha256").update(JSON.stringify([upstreamDigest, extensionDigest])).digest("hex")}`;
+}
+function safeValue(value) {
+  return JSON.parse(JSON.stringify(value));
+}
 function modelIds(value) {
   if (value === null || typeof value !== "object" || Array.isArray(value)) return /* @__PURE__ */ new Set();
   const data = value.data;
@@ -1023,11 +1506,11 @@ 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(
+  const generation = `sha256:${createHash5("sha256").update(JSON.stringify(routes.map((route) => route.gatewayModelId))).digest("hex")}`;
+  const digest3 = `sha256:${createHash5("sha256").update(
     JSON.stringify([generation, defaultAlias, routes.map((route) => [route.alias, route.gatewayModelId])])
   ).digest("hex")}`;
-  return { generation, digest: digest2, defaultAlias, routes };
+  return { generation, digest: digest3, defaultAlias, routes };
 }
 function relativePointer(collection, pointer) {
   const prefix = `/${collection}`;
@@ -1036,9 +1519,11 @@ function relativePointer(collection, pointer) {
 }
 async function activateCliProxyGateway(context, input) {
   const registry = context.cliProxyUpstreams;
+  const extensionRegistry = context.cliProxyGatewayExtensions;
   let active;
   let transition = Promise.resolve();
   let unsubscribe = () => void 0;
+  let unsubscribeExtensions = () => void 0;
   let disposePromise;
   let gatewayHandle;
   let publication;
@@ -1059,9 +1544,9 @@ async function activateCliProxyGateway(context, input) {
     refreshGatewayModels: () => scheduleModelRefresh()
   };
   const unbindGatewayUIState = bindGatewayUIState(uiState);
-  const activate = async (catalog, plan) => {
+  const activate = async (catalog, plan, extensionPlan, revision2) => {
     gatewayHandle ??= await context.managedServices.register(cliProxyGatewayDefinition, {
-      revision: plan.catalogDigest
+      revision: revision2
     });
     const handle = gatewayHandle;
     const leases = [];
@@ -1106,6 +1591,14 @@ async function activateCliProxyGateway(context, input) {
           );
         }
       }
+      for (const composition of extensionPlan.composition) {
+        const acquired = await input.client.acquire(composition.source, { signal: input.signal });
+        if (acquired.status !== "ready") {
+          throw activationError(`${composition.connectionId} extension acquisition`, acquired);
+        }
+        leases.push(acquired.lease);
+        sources.push({ source: composition.sourceAlias, lease: acquired.lease });
+      }
       const bindings = [
         {
           targetSlot: "codex-upstreams",
@@ -1114,6 +1607,19 @@ async function activateCliProxyGateway(context, input) {
         {
           targetSlot: "openai-upstreams",
           source: { kind: "safe-literal", value: plan.configuration["openai-compatibility"] }
+        },
+        {
+          targetSlot: "gateway-extensions",
+          source: {
+            kind: "safe-literal",
+            value: safeValue({
+              enabled: true,
+              active: extensionPlan.composition.length > 0,
+              revision: extensionPlan.planDigest,
+              adapters: extensionPlan.configuration.adapters,
+              connections: extensionPlan.configuration.connections
+            })
+          }
         }
       ];
       for (const composition of plan.composition) {
@@ -1131,9 +1637,23 @@ async function activateCliProxyGateway(context, input) {
           });
         }
       }
+      for (const composition of extensionPlan.composition) {
+        bindings.push({
+          targetSlot: "gateway-extensions",
+          targetPointer: composition.originPointer,
+          source: { kind: "source-origin", source: composition.sourceAlias, origin: "api" }
+        });
+        if (composition.authorizationPointer !== void 0) {
+          bindings.push({
+            targetSlot: "gateway-extensions",
+            targetPointer: composition.authorizationPointer,
+            source: { kind: "source-authorization", source: composition.sourceAlias }
+          });
+        }
+      }
       const materialized = await input.client.materialize({
         target: handle.binding,
-        revision: plan.catalogDigest,
+        revision: revision2,
         sources,
         bindings
       }, { signal: input.signal });
@@ -1149,6 +1669,10 @@ async function activateCliProxyGateway(context, input) {
       const actualGatewayModels = await readGatewayModels();
       const expectedGatewayModels = catalog.groups.flatMap(
         (group) => group.providers.flatMap((provider) => provider.models.map((model) => model.gatewayModelId))
+      ).concat(
+        extensionPlan.configuration.connections.flatMap(
+          (connection) => connection.enabled ? connection.models.map((model) => model.gatewayModelId) : []
+        )
       );
       const missingGatewayModels = expectedGatewayModels.filter((model) => !actualGatewayModels.has(model));
       if (missingGatewayModels.length > 0) {
@@ -1215,7 +1739,10 @@ async function activateCliProxyGateway(context, input) {
     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 extensionPlan = extensionRegistry.plan(input.owner.pluginGeneration);
+    assertExtensionPlan(extensionPlan);
+    const revision2 = combinedRevision(catalog.catalogDigest, extensionPlan.planDigest);
+    if (active?.revision === revision2) return;
     const previous = active;
     active = void 0;
     activeRevision = void 0;
@@ -1224,16 +1751,16 @@ async function activateCliProxyGateway(context, input) {
     assertPlan(plan);
     if (gatewayHandle === void 0) {
       gatewayHandle = await context.managedServices.register(cliProxyGatewayDefinition, {
-        revision: plan.catalogDigest
+        revision: revision2
       });
     }
     if (input.signal.aborted) return;
-    const cleanup = await activate(catalog, plan);
+    const cleanup = await activate(catalog, plan, extensionPlan, revision2);
     if (input.signal.aborted) {
       await cleanup();
       return;
     }
-    active = { revision: catalog.registryRevision, dispose: cleanup };
+    active = { revision: revision2, dispose: cleanup };
   };
   const schedule = () => {
     const pending = transition.then(reconcile);
@@ -1252,6 +1779,7 @@ async function activateCliProxyGateway(context, input) {
     if (disposePromise !== void 0) return disposePromise;
     disposePromise = (async () => {
       unsubscribe();
+      unsubscribeExtensions();
       unbindGatewayUIState();
       await transition;
       const failures = [];
@@ -1282,6 +1810,9 @@ async function activateCliProxyGateway(context, input) {
     unsubscribe = registry.subscribe(() => {
       void schedule().catch(() => void 0);
     });
+    unsubscribeExtensions = extensionRegistry.subscribe(() => {
+      void schedule().catch(() => void 0);
+    });
     const onAbort = () => {
       void dispose().catch(() => void 0);
     };
@@ -1312,10 +1843,21 @@ var gatewayApply = async (context, input) => {
   await activateCliProxyGateway(context, input);
 };
 var apply = Object.assign(gatewayApply, {
-  inject: ["managedServices", CLI_PROXY_UPSTREAM_REGISTRY_SERVICE_V1]
+  inject: [
+    "managedServices",
+    CLI_PROXY_UPSTREAM_REGISTRY_SERVICE_V1,
+    CLI_PROXY_GATEWAY_EXTENSION_REGISTRY_SERVICE_V1
+  ]
 });
 export {
+  CLI_PROXY_GATEWAY_ADAPTER_CONTRACT_V1,
+  CLI_PROXY_GATEWAY_ADAPTER_SCHEMA_V1,
   CLI_PROXY_GATEWAY_CODEX_UPSTREAMS_SCHEMA_V1,
+  CLI_PROXY_GATEWAY_CONNECTION_CONTRACT_V1,
+  CLI_PROXY_GATEWAY_CONNECTION_SCHEMA_V1,
+  CLI_PROXY_GATEWAY_EXTENSION_PLAN_CONTRACT_V1,
+  CLI_PROXY_GATEWAY_EXTENSION_PLAN_SCHEMA_V1,
+  CLI_PROXY_GATEWAY_EXTENSION_REGISTRY_SERVICE_V1,
   CLI_PROXY_GATEWAY_MANAGEMENT_V1,
   CLI_PROXY_GATEWAY_MODEL_CATALOG_SCHEMA_V1,
   CLI_PROXY_GATEWAY_OPENAI_UPSTREAMS_SCHEMA_V1,
@@ -1326,12 +1868,14 @@ export {
   CLI_PROXY_UPSTREAM_DESCRIPTOR_CONTRACT_V1,
   CLI_PROXY_UPSTREAM_DESCRIPTOR_SCHEMA_V1,
   CLI_PROXY_UPSTREAM_REGISTRY_SERVICE_V1,
+  CliProxyGatewayExtensionRegistryV1,
   CliProxyUpstreamRegistryV1,
   activateCliProxyGateway,
   apply,
   cliProxyGatewayDefinition,
   cliProxyGatewayDefinitionRevision,
   contextServices,
+  createCliProxyGatewayExtensionRegistrarV1,
   createCliProxyUpstreamRegistrarV1,
   managedServiceUI
 };