@omnicross/core 0.1.0 → 0.1.1

package/dist/pipeline/resolveSubscriptionChain.d.cts

@@ -0,0 +1,68 @@
+import { TransformerService } from '../transformer/TransformerService.cjs';
+import { Transformer, ResolvedTransformerChain } from '../transformer/types.cjs';
+import { SubscriptionAuthProfile } from './SubscriptionAuthSource.cjs';
+import '@omnicross/contracts/subscription-types';
+import './AuthSource.cjs';
+import './SubscriptionAuthStrategy.cjs';
+
+/**
+ * resolveSubscriptionChain — shared subscription provider-chain resolver.
+ *
+ * Cross-vendor subscription "route-to" generalization (task #29). The Codex /
+ * OpenAI-Responses ingress subscription plan used to HARD-CODE its provider
+ * transformer chain to a single `OpenAIResponseTransformer`, ignoring the
+ * subscription profile's own `providerTransformerNames`. That only produced
+ * Responses-API bytes upstream — correct for the codex/ChatGPT subscription
+ * (whose profile chain IS `['openai-response']`), but WRONG for any
+ * subscription whose upstream speaks a non-Responses wire.
+ *
+ * This helper mirrors `SubscriptionDispatcher.resolveTransformers`: it resolves
+ * the profile's transformer NAMES into instances via the shared
+ * `TransformerService` (the SAME registry the Anthropic-ingress dispatcher uses),
+ * so the Responses ingress re-encodes Unified → the target wire exactly like the
+ * BYO plan's `resolveProviderChain`. The endpoint transformer stays
+ * `OpenAIResponseTransformer` (the ingress wire is Responses) — so the full
+ * exchange is:
+ *
+ *   Responses → (OpenAIResponseTransformer decode) → Unified
+ *             → (profile providerTransformers encode) → target wire → upstream
+ *   target wire → (profile providerTransformers decode) → Unified
+ *             → (OpenAIResponseTransformer encode) → Responses → Codex CLI
+ *
+ * BYTE-IDENTICAL codex preservation: the codex profile's
+ * `providerTransformerNames` is `['openai-response']`, which resolves to the
+ * SAME `OpenAIResponseTransformer` instance the ingress already used — so the
+ * codex case is unchanged. The fallback (empty/missing names) ALSO yields the
+ * shared `OpenAIResponseTransformer`, so a profile that omits names behaves as
+ * before.
+ *
+ * @module pipeline/resolveSubscriptionChain
+ */
+
+/**
+ * Resolve a subscription profile's provider/model transformer chain.
+ *
+ * @param profile               the subscription profile (carries the names).
+ * @param transformerService    the shared registry (from `llmConfig.getTransformerService()`).
+ * @param fallbackEndpoint      the shared `OpenAIResponseTransformer` instance,
+ *                              used when the profile declares NO provider names
+ *                              (preserves the prior hard-coded behavior).
+ * @param overrideNames         OPTIONAL explicit provider transformer names that
+ *                              SUPERSEDE the profile's static
+ *                              `providerTransformerNames` — the opencodego zen
+ *                              seam (Phase 3) feeds the shape-resolved chain here
+ *                              (e.g. `['openai-response']` / `['gemini']`). When
+ *                              `undefined` the static field is read exactly as
+ *                              before (codex byte-identity). An explicit EMPTY
+ *                              array means "no provider chain" (the zen anthropic
+ *                              shape — though that path is same-format and never
+ *                              calls this) and falls back to `[fallbackEndpoint]`
+ *                              like the absent-names case.
+ *
+ * @returns the resolved chain. `providerTransformers` is the resolved provider
+ *   names (or `[fallbackEndpoint]` when none declared); `modelTransformers` is the
+ *   profile's resolved model names (usually empty).
+ */
+declare function resolveSubscriptionChain(profile: SubscriptionAuthProfile, transformerService: TransformerService | undefined, fallbackEndpoint: Transformer, overrideNames?: readonly string[]): ResolvedTransformerChain;
+
+export { resolveSubscriptionChain };

package/dist/pipeline/resolveSubscriptionChain.d.ts

@@ -0,0 +1,68 @@
+import { TransformerService } from '../transformer/TransformerService.js';
+import { Transformer, ResolvedTransformerChain } from '../transformer/types.js';
+import { SubscriptionAuthProfile } from './SubscriptionAuthSource.js';
+import '@omnicross/contracts/subscription-types';
+import './AuthSource.js';
+import './SubscriptionAuthStrategy.js';
+
+/**
+ * resolveSubscriptionChain — shared subscription provider-chain resolver.
+ *
+ * Cross-vendor subscription "route-to" generalization (task #29). The Codex /
+ * OpenAI-Responses ingress subscription plan used to HARD-CODE its provider
+ * transformer chain to a single `OpenAIResponseTransformer`, ignoring the
+ * subscription profile's own `providerTransformerNames`. That only produced
+ * Responses-API bytes upstream — correct for the codex/ChatGPT subscription
+ * (whose profile chain IS `['openai-response']`), but WRONG for any
+ * subscription whose upstream speaks a non-Responses wire.
+ *
+ * This helper mirrors `SubscriptionDispatcher.resolveTransformers`: it resolves
+ * the profile's transformer NAMES into instances via the shared
+ * `TransformerService` (the SAME registry the Anthropic-ingress dispatcher uses),
+ * so the Responses ingress re-encodes Unified → the target wire exactly like the
+ * BYO plan's `resolveProviderChain`. The endpoint transformer stays
+ * `OpenAIResponseTransformer` (the ingress wire is Responses) — so the full
+ * exchange is:
+ *
+ *   Responses → (OpenAIResponseTransformer decode) → Unified
+ *             → (profile providerTransformers encode) → target wire → upstream
+ *   target wire → (profile providerTransformers decode) → Unified
+ *             → (OpenAIResponseTransformer encode) → Responses → Codex CLI
+ *
+ * BYTE-IDENTICAL codex preservation: the codex profile's
+ * `providerTransformerNames` is `['openai-response']`, which resolves to the
+ * SAME `OpenAIResponseTransformer` instance the ingress already used — so the
+ * codex case is unchanged. The fallback (empty/missing names) ALSO yields the
+ * shared `OpenAIResponseTransformer`, so a profile that omits names behaves as
+ * before.
+ *
+ * @module pipeline/resolveSubscriptionChain
+ */
+
+/**
+ * Resolve a subscription profile's provider/model transformer chain.
+ *
+ * @param profile               the subscription profile (carries the names).
+ * @param transformerService    the shared registry (from `llmConfig.getTransformerService()`).
+ * @param fallbackEndpoint      the shared `OpenAIResponseTransformer` instance,
+ *                              used when the profile declares NO provider names
+ *                              (preserves the prior hard-coded behavior).
+ * @param overrideNames         OPTIONAL explicit provider transformer names that
+ *                              SUPERSEDE the profile's static
+ *                              `providerTransformerNames` — the opencodego zen
+ *                              seam (Phase 3) feeds the shape-resolved chain here
+ *                              (e.g. `['openai-response']` / `['gemini']`). When
+ *                              `undefined` the static field is read exactly as
+ *                              before (codex byte-identity). An explicit EMPTY
+ *                              array means "no provider chain" (the zen anthropic
+ *                              shape — though that path is same-format and never
+ *                              calls this) and falls back to `[fallbackEndpoint]`
+ *                              like the absent-names case.
+ *
+ * @returns the resolved chain. `providerTransformers` is the resolved provider
+ *   names (or `[fallbackEndpoint]` when none declared); `modelTransformers` is the
+ *   profile's resolved model names (usually empty).
+ */
+declare function resolveSubscriptionChain(profile: SubscriptionAuthProfile, transformerService: TransformerService | undefined, fallbackEndpoint: Transformer, overrideNames?: readonly string[]): ResolvedTransformerChain;
+
+export { resolveSubscriptionChain };

package/dist/pipeline/resolveSubscriptionChain.js

@@ -0,0 +1,43 @@
+// src/pipeline/resolveSubscriptionChain.ts
+function resolveOne(transformerService, name) {
+  const t = transformerService.getTransformer(name);
+  if (!t) return null;
+  return typeof t === "function" ? new t() : t;
+}
+function resolveSubscriptionChain(profile, transformerService, fallbackEndpoint, overrideNames) {
+  const providerNames = overrideNames ?? profile.providerTransformerNames ?? [];
+  const modelNames = profile.modelTransformerNames ?? [];
+  if (providerNames.length === 0) {
+    return { providerTransformers: [fallbackEndpoint], modelTransformers: [] };
+  }
+  if (!transformerService) {
+    throw new Error(
+      "[resolveSubscriptionChain] profile declares providerTransformerNames but no TransformerService is wired"
+    );
+  }
+  const providerTransformers = [];
+  for (const name of providerNames) {
+    const instance = resolveOne(transformerService, name);
+    if (!instance) {
+      console.warn(`[resolveSubscriptionChain] Transformer not registered: ${name}`);
+      continue;
+    }
+    providerTransformers.push(instance);
+  }
+  const modelTransformers = [];
+  for (const name of modelNames) {
+    const instance = resolveOne(transformerService, name);
+    if (!instance) {
+      console.warn(`[resolveSubscriptionChain] Model transformer not registered: ${name}`);
+      continue;
+    }
+    modelTransformers.push(instance);
+  }
+  if (providerTransformers.length === 0) {
+    return { providerTransformers: [fallbackEndpoint], modelTransformers };
+  }
+  return { providerTransformers, modelTransformers };
+}
+export {
+  resolveSubscriptionChain
+};

package/dist/ports/provider-config-source.cjs

@@ -0,0 +1,18 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/ports/provider-config-source.ts
+var provider_config_source_exports = {};
+module.exports = __toCommonJS(provider_config_source_exports);

package/dist/ports/provider-config-source.d.cts

@@ -0,0 +1,51 @@
+import { LLMProvider, AgentDefaultModels, GlobalModelParameters } from '@omnicross/contracts/llm-config';
+import { ResolvedTransformerChain, Transformer } from '../transformer/types.cjs';
+import { TransformerService } from '../transformer/TransformerService.cjs';
+
+/**
+ * `ProviderConfigSource` — core-owned port for the provider catalog + routing +
+ * transformer-chain reads the serving core needs from its host config service.
+ *
+ * The serving core (`pipeline` / `transformer` / `provider-proxy` /
+ * `completion` / `outbound-api`) MUST depend on THIS interface, never on the
+ * host's concrete config-service class as a type. The host supplies the impl
+ * at bootstrap (its config service implementing `ProviderConfigSource` is the
+ * compile-time assignability guard).
+ *
+ * The surface is sized to EXACTLY the ten methods the core invokes today —
+ * signatures copied verbatim from the host's config service so the host stays
+ * structurally assignable with zero behavior change.
+ *
+ * NOTE (Phase-1 narrowing, omnicross): `getTransformerService()` is a
+ * transformer-registry accessor that returns a CORE class (`TransformerService`,
+ * not a host class), so exposing it through this port is sound for 0b. It is a
+ * separate concern from provider-catalog reads, however; splitting it into its
+ * own narrower port is deferred to Phase 1 (see design Q1). Do NOT split now.
+ *
+ * @module ports/provider-config-source
+ */
+
+interface ProviderConfigSource {
+    getProvider(id: string): Promise<LLMProvider | null>;
+    /** @deprecated mirror of the host method — router-based routing is a no-op today. */
+    resolveRoutedModel(providerId: string, modelId: string): Promise<{
+        isRouted: boolean;
+        actualProviderId: string;
+        actualModelId: string;
+        routerId?: string;
+        routerName?: string;
+    } | null>;
+    resolveEffectiveModels(): Promise<{
+        background?: string;
+        vision?: string;
+    }>;
+    getAgentDefaultModels(): Promise<AgentDefaultModels>;
+    hasVisionCapability(providerId: string, modelId: string): Promise<boolean>;
+    getGlobalModelParameters(): Promise<GlobalModelParameters>;
+    getDiscoveredModelMaxTokens(providerId: string, modelId: string): Promise<number | undefined>;
+    resolveTransformerChain(providerId: string, model?: string): Promise<ResolvedTransformerChain>;
+    getMainTransformer(providerId: string): Promise<Transformer | null>;
+    getTransformerService(): TransformerService | undefined;
+}
+
+export type { ProviderConfigSource };

package/dist/ports/provider-config-source.d.ts

@@ -0,0 +1,51 @@
+import { LLMProvider, AgentDefaultModels, GlobalModelParameters } from '@omnicross/contracts/llm-config';
+import { ResolvedTransformerChain, Transformer } from '../transformer/types.js';
+import { TransformerService } from '../transformer/TransformerService.js';
+
+/**
+ * `ProviderConfigSource` — core-owned port for the provider catalog + routing +
+ * transformer-chain reads the serving core needs from its host config service.
+ *
+ * The serving core (`pipeline` / `transformer` / `provider-proxy` /
+ * `completion` / `outbound-api`) MUST depend on THIS interface, never on the
+ * host's concrete config-service class as a type. The host supplies the impl
+ * at bootstrap (its config service implementing `ProviderConfigSource` is the
+ * compile-time assignability guard).
+ *
+ * The surface is sized to EXACTLY the ten methods the core invokes today —
+ * signatures copied verbatim from the host's config service so the host stays
+ * structurally assignable with zero behavior change.
+ *
+ * NOTE (Phase-1 narrowing, omnicross): `getTransformerService()` is a
+ * transformer-registry accessor that returns a CORE class (`TransformerService`,
+ * not a host class), so exposing it through this port is sound for 0b. It is a
+ * separate concern from provider-catalog reads, however; splitting it into its
+ * own narrower port is deferred to Phase 1 (see design Q1). Do NOT split now.
+ *
+ * @module ports/provider-config-source
+ */
+
+interface ProviderConfigSource {
+    getProvider(id: string): Promise<LLMProvider | null>;
+    /** @deprecated mirror of the host method — router-based routing is a no-op today. */
+    resolveRoutedModel(providerId: string, modelId: string): Promise<{
+        isRouted: boolean;
+        actualProviderId: string;
+        actualModelId: string;
+        routerId?: string;
+        routerName?: string;
+    } | null>;
+    resolveEffectiveModels(): Promise<{
+        background?: string;
+        vision?: string;
+    }>;
+    getAgentDefaultModels(): Promise<AgentDefaultModels>;
+    hasVisionCapability(providerId: string, modelId: string): Promise<boolean>;
+    getGlobalModelParameters(): Promise<GlobalModelParameters>;
+    getDiscoveredModelMaxTokens(providerId: string, modelId: string): Promise<number | undefined>;
+    resolveTransformerChain(providerId: string, model?: string): Promise<ResolvedTransformerChain>;
+    getMainTransformer(providerId: string): Promise<Transformer | null>;
+    getTransformerService(): TransformerService | undefined;
+}
+
+export type { ProviderConfigSource };

package/dist/ports/web-search-backend.cjs

@@ -0,0 +1,18 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/ports/web-search-backend.ts
+var web_search_backend_exports = {};
+module.exports = __toCommonJS(web_search_backend_exports);

package/dist/ports/web-search-backend.d.cts

@@ -0,0 +1,29 @@
+import { WebSearchProviderId, WebSearchOptions, WebSearchResponse, JinaReaderResponse } from '@omnicross/contracts/websearch-types';
+
+/**
+ * `WebSearchBackend` — core-owned port for the web-search service the serving
+ * core's built-in `web_search` tool executor and the Anthropic proxy hints use.
+ *
+ * The serving core MUST depend on THIS interface, never on the concrete host
+ * `WebSearchService` class as a type. The host already exposes a superset of
+ * this surface, so it is passed directly with NO adapter.
+ *
+ * The surface is EXACTLY the three methods the core invokes
+ * (`search`/`isProviderEnabled`/`readUrl`), signatures matching
+ * `WebSearchService`. The argument/return types are `@omnicross/contracts`
+ * contract types (not host classes), so they cross into a Phase-1 package cleanly.
+ *
+ * @module ports/web-search-backend
+ */
+
+interface WebSearchBackend {
+    search(query: string, providerId: WebSearchProviderId, options?: WebSearchOptions): Promise<WebSearchResponse>;
+    isProviderEnabled(id: WebSearchProviderId): boolean;
+    readUrl(url: string, options?: {
+        timeout?: number;
+        signal?: AbortSignal;
+        apiKey?: string;
+    }): Promise<JinaReaderResponse>;
+}
+
+export type { WebSearchBackend };

package/dist/ports/web-search-backend.d.ts

@@ -0,0 +1,29 @@
+import { WebSearchProviderId, WebSearchOptions, WebSearchResponse, JinaReaderResponse } from '@omnicross/contracts/websearch-types';
+
+/**
+ * `WebSearchBackend` — core-owned port for the web-search service the serving
+ * core's built-in `web_search` tool executor and the Anthropic proxy hints use.
+ *
+ * The serving core MUST depend on THIS interface, never on the concrete host
+ * `WebSearchService` class as a type. The host already exposes a superset of
+ * this surface, so it is passed directly with NO adapter.
+ *
+ * The surface is EXACTLY the three methods the core invokes
+ * (`search`/`isProviderEnabled`/`readUrl`), signatures matching
+ * `WebSearchService`. The argument/return types are `@omnicross/contracts`
+ * contract types (not host classes), so they cross into a Phase-1 package cleanly.
+ *
+ * @module ports/web-search-backend
+ */
+
+interface WebSearchBackend {
+    search(query: string, providerId: WebSearchProviderId, options?: WebSearchOptions): Promise<WebSearchResponse>;
+    isProviderEnabled(id: WebSearchProviderId): boolean;
+    readUrl(url: string, options?: {
+        timeout?: number;
+        signal?: AbortSignal;
+        apiKey?: string;
+    }): Promise<JinaReaderResponse>;
+}
+
+export type { WebSearchBackend };

package/dist/ports.d.cts

@@ -1,15 +1,18 @@
 export { C as CorePaths, a as CoreUsageEvent, b as CoreUsageTokenCounts, U as UsageEventSink } from './usage-event-sink-BX7FE1NL.cjs';
 export { L as Logger } from './ApiKeyPoolService-BmMkau07.cjs';
-export { P as ProviderConfigSource, U as UsageSink, W as WebSearchBackend } from './types-DZIQbgp0.cjs';
-export { O as OutboundCredentialStore } from './types-CGGrKqC_.cjs';
+export { ProviderConfigSource } from './ports/provider-config-source.cjs';
+export { WebSearchBackend } from './ports/web-search-backend.cjs';
+export { UsageRecorderImport as UsageSink } from './provider-proxy/types.cjs';
+export { OutboundKeyDb as OutboundCredentialStore } from './outbound-api/types.cjs';
 import '@omnicross/contracts/llm-config';
+import './transformer/types.cjs';
+import './transformer/TransformerService.cjs';
+import '@omnicross/contracts/websearch-types';
 import 'node:http';
 import '@omnicross/contracts/completion-types';
 import '@omnicross/contracts/subscription-types';
 import '@omnicross/contracts/usage-types';
-import './SubscriptionAuthSource-Cr4fVEYY.cjs';
+import './pipeline/AuthSource.cjs';
+import './pipeline/SubscriptionAuthSource.cjs';
 import './pipeline/SubscriptionAuthStrategy.cjs';
-import './transformer/types.cjs';
-import './transformer/TransformerService.cjs';
-import '@omnicross/contracts/websearch-types';
-import './ProviderProxy-f_8ziIhW.cjs';
+import './ProviderProxy-CnMQYN59.cjs';

package/dist/ports.d.ts

@@ -1,15 +1,18 @@
 export { C as CorePaths, a as CoreUsageEvent, b as CoreUsageTokenCounts, U as UsageEventSink } from './usage-event-sink-BX7FE1NL.js';
 export { L as Logger } from './ApiKeyPoolService-BmMkau07.js';
-export { P as ProviderConfigSource, U as UsageSink, W as WebSearchBackend } from './types-DCzHkhJt.js';
-export { O as OutboundCredentialStore } from './types-CbCN2NQP.js';
+export { ProviderConfigSource } from './ports/provider-config-source.js';
+export { WebSearchBackend } from './ports/web-search-backend.js';
+export { UsageRecorderImport as UsageSink } from './provider-proxy/types.js';
+export { OutboundKeyDb as OutboundCredentialStore } from './outbound-api/types.js';
 import '@omnicross/contracts/llm-config';
+import './transformer/types.js';
+import './transformer/TransformerService.js';
+import '@omnicross/contracts/websearch-types';
 import 'node:http';
 import '@omnicross/contracts/completion-types';
 import '@omnicross/contracts/subscription-types';
 import '@omnicross/contracts/usage-types';
-import './SubscriptionAuthSource-D89zmiSS.js';
+import './pipeline/AuthSource.js';
+import './pipeline/SubscriptionAuthSource.js';
 import './pipeline/SubscriptionAuthStrategy.js';
-import './transformer/types.js';
-import './transformer/TransformerService.js';
-import '@omnicross/contracts/websearch-types';
-import './ProviderProxy-vjt8sQQk.js';
+import './ProviderProxy-C-xqrkKi.js';