@omnicross/core 0.1.0 → 0.1.2

package/dist/pipeline/executeProviderCall.d.ts

@@ -0,0 +1,149 @@
+import { TransformerChainExecutor, ChainExecutionOptions } from '../transformer/TransformerChainExecutor.js';
+import { UnifiedChatRequest, LLMProvider, ResolvedTransformerChain, Transformer, RequestConfig } from '../transformer/types.js';
+
+/**
+ * executeProviderCall — shared provider-request exchange core.
+ *
+ * Phase 1 of the `provider-request-pipeline` OpenSpec change (design D2/D4/D6).
+ *
+ * The three consumer paths (the wire-format proxy handler, the host engine
+ * adapter, TransformerHandler) each re-implemented the same middle:
+ *
+ *   executor.executeRequestChain(...) → resolve URL → assemble headers
+ *   → fetch → (optionally) executor.executeResponseChain(...)
+ *
+ * This module owns ONLY that common exchange. Every step that diverges
+ * between the three sites is injected via options so each call site keeps
+ * its CURRENT behavior verbatim:
+ *
+ *   - URL building       → `resolveUrl(config)`
+ *   - header assembly    → `buildHeaders(config)`
+ *   - post-transform body mutation → `prepareBody(requestBody, config)`
+ *   - fetch mechanism    → `fetchFn(url, headers, body)`
+ *   - endpoint transform → `endpointTransformer` (proxy = Anthropic; others omit)
+ *   - response chain     → `runResponseChain` flag + `responseChainRequest`
+ *
+ * IMPORTANT subtleties preserved verbatim:
+ *
+ *   1. The response chain's FIRST argument is the REQUEST body, NOT the
+ *      mutated `prepareBody` output. Each site passes a DIFFERENT variable
+ *      there today (proxy → post-transform `requestBody`; Adapter/Handler →
+ *      the pre-transform `unifiedRequest`), so the core does not hard-code
+ *      it — `responseChainRequest` is supplied by the caller when
+ *      `runResponseChain` is true.
+ *
+ *   2. The engine adapter and Handler check `response.ok` on the RAW fetch response
+ *      BEFORE running the response chain. Those sites therefore set
+ *      `runResponseChain: false` (the default) and run `executeResponseChain`
+ *      themselves at the call site after their `.ok` gate. The proxy uses
+ *      `fetchWithRetry` (no raw `.ok` gate between fetch and the response
+ *      chain) so it sets `runResponseChain: true` and lets the core run it.
+ *
+ * @module pipeline/executeProviderCall
+ */
+
+/**
+ * Inputs for {@link executeProviderCall}. Everything that differs between
+ * the three ingress adapters is injected here; the core owns only the
+ * fixed orchestration between `executeRequestChain` and the fetch.
+ */
+interface ProviderCallContext {
+    /** Shared (stateless) transformer-chain executor. */
+    executor: TransformerChainExecutor;
+    /**
+     * The request to send into the request chain. For the proxy this is the
+     * raw Anthropic wire body (decoded by `endpointTransformer`); for the
+     * unified ingresses this is a `UnifiedChatRequest`.
+     */
+    request: UnifiedChatRequest | Record<string, unknown>;
+    /** Provider config in transformer runtime shape. */
+    provider: LLMProvider;
+    /** Resolved transformer chain (provider + model transformers). */
+    chain: ResolvedTransformerChain;
+    /**
+     * Endpoint transformer — present only for wire-format ingress (the proxy
+     * passes `AnthropicTransformer`). Omitted for unified ingresses.
+     */
+    endpointTransformer?: Transformer;
+    /**
+     * 1M-context opt-in, threaded straight through to
+     * `executeRequestChain`'s `extendedContext` option, exactly as the call
+     * sites pass it today.
+     */
+    extendedContext?: ChainExecutionOptions['extendedContext'];
+    /**
+     * Build the target URL from the post-request-chain `config`. Each site
+     * supplies its CURRENT URL logic:
+     *   - proxy:        always `buildProviderApiUrl(...)` (ignores config.url)
+     *   - Adapter/Handler: `config.url instanceof URL ? config.url.toString() : buildProviderApiUrl(...)`
+     */
+    resolveUrl: (config: RequestConfig) => string;
+    /**
+     * Assemble the outbound headers from the post-request-chain `config`.
+     * Each site supplies its CURRENT header logic:
+     *   - proxy:        getProviderHeaders + config.headers EXCLUDING AUTH_HEADER_KEYS
+     *   - Adapter/Handler: getProviderHeaders + config.headers + OpenRouter app headers
+     */
+    buildHeaders: (config: RequestConfig) => Record<string, string>;
+    /**
+     * Post-transform / pre-fetch body mutation seam (design D4). Applied to
+     * the request-chain output `requestBody` immediately before fetch. The
+     * default is identity. NOTE: the value returned here becomes the fetched
+     * body ONLY — the response chain still receives the pre-mutation request
+     * (see `responseChainRequest`).
+     */
+    prepareBody?: (requestBody: unknown, config: RequestConfig) => unknown | Promise<unknown>;
+    /**
+     * The fetch mechanism. Each site supplies its CURRENT mechanism:
+     *   - proxy:        `this.deps.errors.fetchWithRetry(url, headers, body, model)`
+     *   - Adapter:      `fetch(url, { ..., signal: AbortSignal.timeout(...) })`
+     *   - Handler:      `fetch(url, { ... })`
+     */
+    fetchFn: (url: string, headers: Record<string, string>, body: unknown) => Promise<Response>;
+    /**
+     * When `true`, the core runs `executeResponseChain` on the fetched
+     * response and returns the TRANSFORMED response. When `false` (default),
+     * the core returns the RAW fetched response and the caller runs the
+     * response chain itself — this preserves call sites that gate on
+     * `response.ok` BEFORE the response chain (Adapter / Handler).
+     */
+    runResponseChain?: boolean;
+    /**
+     * The first argument passed to `executeResponseChain` when
+     * `runResponseChain` is true. This is REQUIRED in that mode because the
+     * sites diverge on which variable they pass (proxy → post-transform
+     * `requestBody`; the unified ingresses → the pre-transform request). The
+     * core never assumes it equals `prepareBody`'s output.
+     */
+    responseChainRequest?: UnifiedChatRequest;
+}
+/**
+ * Result of the common exchange.
+ *
+ * `response` is the TRANSFORMED response when `runResponseChain` was true,
+ * otherwise the RAW fetched response. The remaining fields expose the
+ * request-chain outputs so callers can run the response chain themselves
+ * (when `runResponseChain` is false) with the exact variables they used
+ * before, and so the wire-capture / logging hooks keep their inputs.
+ */
+interface ProviderCallResult {
+    /** Transformed response (runResponseChain=true) or raw response (false). */
+    response: Response;
+    /** Request-chain output body (pre-`prepareBody`). */
+    requestBody: unknown;
+    /** Final body actually sent to `fetchFn` (post-`prepareBody`). */
+    finalBody: unknown;
+    /** Request-chain output config (headers/url/etc.). */
+    config: RequestConfig;
+    /** The resolved target URL. */
+    url: string;
+    /** The assembled outbound headers. */
+    headers: Record<string, string>;
+}
+/**
+ * Run the common provider-request exchange. See the module + option JSDoc
+ * for the precise per-site contract this preserves.
+ */
+declare function executeProviderCall(ctx: ProviderCallContext): Promise<ProviderCallResult>;
+
+export { type ProviderCallContext, type ProviderCallResult, executeProviderCall };

package/dist/pipeline/executeProviderCall.js

@@ -0,0 +1,6 @@
+import {
+  executeProviderCall
+} from "../chunk-JO5NLTLY.js";
+export {
+  executeProviderCall
+};

package/dist/pipeline/resolveProviderChain.cjs

@@ -0,0 +1,6 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunkQXD4MV2Xcjs = require('../chunk-QXD4MV2X.cjs');
+
+
+exports.resolveProviderChain = _chunkQXD4MV2Xcjs.resolveProviderChain;

package/dist/pipeline/resolveProviderChain.d.cts

@@ -0,0 +1,58 @@
+import { ProviderConfigSource } from '../ports/provider-config-source.cjs';
+import { Transformer } from '../transformer/types.cjs';
+import '@omnicross/contracts/llm-config';
+import '../transformer/TransformerService.cjs';
+
+/**
+ * resolveProviderChain — shared transformer-chain resolution helper.
+ *
+ * Phase 0 of the `provider-request-pipeline` OpenSpec change.
+ * All three consumer paths (TransformerHandler, the host engine adapter,
+ * and the wire-format proxy handler) previously duplicated the same
+ * resolveTransformerChain + getMainTransformer + shallow-copy + unshift
+ * block verbatim. This module extracts that single shared helper so the
+ * logic lives in exactly one place.
+ *
+ * IMPORTANT: body mutations that are proxy-specific (ReasoningTransformer
+ * auto-inject, thinkingLevel body-inject) are NOT part of this helper —
+ * they remain at each call site as before.
+ *
+ * @module pipeline/resolveProviderChain
+ */
+
+/** The resolved chain returned by each consumer. */
+interface ResolvedProviderChain {
+    chain: {
+        providerTransformers: Transformer[];
+        modelTransformers: Transformer[];
+    };
+    /**
+     * The main transformer resolved for this provider, or `null` when none
+     * is configured. Callers that need the transformer name (e.g. to pass
+     * into `getProviderCacheCaps` as `mainTransformerName`) can read
+     * `mainTransformer?.name` from this field.
+     */
+    mainTransformer: Transformer | null;
+    /**
+     * `true` when there is at least one transformer in either array — used
+     * by callers to gate the transformer-chain path vs the direct-API
+     * fallback.
+     */
+    hasTransformers: boolean;
+}
+/**
+ * Resolve the full transformer chain for a provider + model combination.
+ *
+ * Semantics (identical to all three former inline copies):
+ * 1. Call `llmConfig.resolveTransformerChain(providerId, model)` to get the
+ *    cached chain.
+ * 2. Call `llmConfig.getMainTransformer(providerId)` to get the main
+ *    transformer (e.g. GeminiTransformer for Google providers).
+ * 3. Shallow-copy both arrays so the cached reference is not mutated.
+ * 4. `unshift` the main transformer into `providerTransformers` unless a
+ *    transformer with the same `.name` is already present.
+ * 5. Compute `hasTransformers`.
+ */
+declare function resolveProviderChain(llmConfig: ProviderConfigSource, providerId: string, model: string): Promise<ResolvedProviderChain>;
+
+export { type ResolvedProviderChain, resolveProviderChain };

package/dist/pipeline/resolveProviderChain.d.ts

@@ -0,0 +1,58 @@
+import { ProviderConfigSource } from '../ports/provider-config-source.js';
+import { Transformer } from '../transformer/types.js';
+import '@omnicross/contracts/llm-config';
+import '../transformer/TransformerService.js';
+
+/**
+ * resolveProviderChain — shared transformer-chain resolution helper.
+ *
+ * Phase 0 of the `provider-request-pipeline` OpenSpec change.
+ * All three consumer paths (TransformerHandler, the host engine adapter,
+ * and the wire-format proxy handler) previously duplicated the same
+ * resolveTransformerChain + getMainTransformer + shallow-copy + unshift
+ * block verbatim. This module extracts that single shared helper so the
+ * logic lives in exactly one place.
+ *
+ * IMPORTANT: body mutations that are proxy-specific (ReasoningTransformer
+ * auto-inject, thinkingLevel body-inject) are NOT part of this helper —
+ * they remain at each call site as before.
+ *
+ * @module pipeline/resolveProviderChain
+ */
+
+/** The resolved chain returned by each consumer. */
+interface ResolvedProviderChain {
+    chain: {
+        providerTransformers: Transformer[];
+        modelTransformers: Transformer[];
+    };
+    /**
+     * The main transformer resolved for this provider, or `null` when none
+     * is configured. Callers that need the transformer name (e.g. to pass
+     * into `getProviderCacheCaps` as `mainTransformerName`) can read
+     * `mainTransformer?.name` from this field.
+     */
+    mainTransformer: Transformer | null;
+    /**
+     * `true` when there is at least one transformer in either array — used
+     * by callers to gate the transformer-chain path vs the direct-API
+     * fallback.
+     */
+    hasTransformers: boolean;
+}
+/**
+ * Resolve the full transformer chain for a provider + model combination.
+ *
+ * Semantics (identical to all three former inline copies):
+ * 1. Call `llmConfig.resolveTransformerChain(providerId, model)` to get the
+ *    cached chain.
+ * 2. Call `llmConfig.getMainTransformer(providerId)` to get the main
+ *    transformer (e.g. GeminiTransformer for Google providers).
+ * 3. Shallow-copy both arrays so the cached reference is not mutated.
+ * 4. `unshift` the main transformer into `providerTransformers` unless a
+ *    transformer with the same `.name` is already present.
+ * 5. Compute `hasTransformers`.
+ */
+declare function resolveProviderChain(llmConfig: ProviderConfigSource, providerId: string, model: string): Promise<ResolvedProviderChain>;
+
+export { type ResolvedProviderChain, resolveProviderChain };

package/dist/pipeline/resolveProviderChain.js

@@ -0,0 +1,6 @@
+import {
+  resolveProviderChain
+} from "../chunk-JWC6APFQ.js";
+export {
+  resolveProviderChain
+};

package/dist/pipeline/resolveSubscriptionChain.cjs

@@ -0,0 +1,6 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunkNYUNU75Acjs = require('../chunk-NYUNU75A.cjs');
+
+
+exports.resolveSubscriptionChain = _chunkNYUNU75Acjs.resolveSubscriptionChain;

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,6 @@
+import {
+  resolveSubscriptionChain
+} from "../chunk-5ERIZW3D.js";
+export {
+  resolveSubscriptionChain
+};

package/dist/ports/gemini-code-assist-resolver.cjs

@@ -1,38 +1,8 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-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);
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
 
-// src/ports/gemini-code-assist-resolver.ts
-var gemini_code_assist_resolver_exports = {};
-__export(gemini_code_assist_resolver_exports, {
-  getGeminiCodeAssistResolver: () => getGeminiCodeAssistResolver,
-  setGeminiCodeAssistResolver: () => setGeminiCodeAssistResolver
-});
-module.exports = __toCommonJS(gemini_code_assist_resolver_exports);
-var resolver = null;
-function setGeminiCodeAssistResolver(impl) {
-  resolver = impl;
-}
-function getGeminiCodeAssistResolver() {
-  return resolver;
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  getGeminiCodeAssistResolver,
-  setGeminiCodeAssistResolver
-});
+
+var _chunkR3HK6R4Bcjs = require('../chunk-R3HK6R4B.cjs');
+
+
+
+exports.getGeminiCodeAssistResolver = _chunkR3HK6R4Bcjs.getGeminiCodeAssistResolver; exports.setGeminiCodeAssistResolver = _chunkR3HK6R4Bcjs.setGeminiCodeAssistResolver;

package/dist/ports/gemini-code-assist-resolver.js

@@ -1,11 +1,7 @@
-// src/ports/gemini-code-assist-resolver.ts
-var resolver = null;
-function setGeminiCodeAssistResolver(impl) {
-  resolver = impl;
-}
-function getGeminiCodeAssistResolver() {
-  return resolver;
-}
+import {
+  getGeminiCodeAssistResolver,
+  setGeminiCodeAssistResolver
+} from "../chunk-DRWHTIIZ.js";
 export {
   getGeminiCodeAssistResolver,
   setGeminiCodeAssistResolver

package/dist/ports/pricing-store.cjs

@@ -0,0 +1 @@
+"use strict";

package/dist/ports/pricing-store.d.cts

@@ -0,0 +1,50 @@
+import { PricingEntry, PricingEntryInput, PricingResolution } from '@omnicross/contracts/pricing-types';
+
+/**
+ * `PricingStore` — core-owned port for pricing-row persistence.
+ *
+ * The pricing engine performs ALL persistence through this interface; the host
+ * embedder supplies the implementation at bootstrap (e.g. a SQLite table or a
+ * JSON file store). Lookups never go through the store — the engine keeps an
+ * in-memory cache loaded from `getAll()`.
+ *
+ * @module ports/pricing-store
+ */
+
+interface PricingStore {
+    /** Return every pricing row. The engine caches the full table in memory. */
+    getAll(): Promise<PricingEntry[]>;
+    /**
+     * Insert or update one row. When `asUserEdit` is true the store MUST mark
+     * the row user-edited (source 'user', `userEdited: true`, `editedAt` now),
+     * protecting it from auto-overwrite during subsequent source refreshes.
+     */
+    upsert(input: PricingEntryInput, asUserEdit: boolean): Promise<PricingEntry>;
+    /**
+     * Apply a batch of entries fetched from a pricing source.
+     *
+     * userEdited-conflict semantics: rows that do not exist locally, or exist
+     * but are NOT user-edited, are upserted (source 'litellm', not user-edited)
+     * and returned in `applied`. Rows whose local copy IS user-edited MUST be
+     * left untouched and returned in `conflicts` as `{ current, incoming }`
+     * pairs for per-row resolution by the user.
+     */
+    bulkApplyFromSource(entries: PricingEntryInput[]): Promise<{
+        applied: PricingEntry[];
+        conflicts: Array<{
+            current: PricingEntry;
+            incoming: PricingEntryInput;
+        }>;
+    }>;
+    /**
+     * Apply per-row conflict decisions: 'overwrite' replaces the local row with
+     * the incoming values (clearing the user-edited mark), 'skip' leaves it
+     * unchanged. Returns overwritten/skipped counts.
+     */
+    applyResolutions(resolutions: Array<{
+        incoming: PricingEntryInput;
+        action: 'overwrite' | 'skip';
+    }>): Promise<PricingResolution>;
+}
+
+export type { PricingStore };

package/dist/ports/pricing-store.d.ts

@@ -0,0 +1,50 @@
+import { PricingEntry, PricingEntryInput, PricingResolution } from '@omnicross/contracts/pricing-types';
+
+/**
+ * `PricingStore` — core-owned port for pricing-row persistence.
+ *
+ * The pricing engine performs ALL persistence through this interface; the host
+ * embedder supplies the implementation at bootstrap (e.g. a SQLite table or a
+ * JSON file store). Lookups never go through the store — the engine keeps an
+ * in-memory cache loaded from `getAll()`.
+ *
+ * @module ports/pricing-store
+ */
+
+interface PricingStore {
+    /** Return every pricing row. The engine caches the full table in memory. */
+    getAll(): Promise<PricingEntry[]>;
+    /**
+     * Insert or update one row. When `asUserEdit` is true the store MUST mark
+     * the row user-edited (source 'user', `userEdited: true`, `editedAt` now),
+     * protecting it from auto-overwrite during subsequent source refreshes.
+     */
+    upsert(input: PricingEntryInput, asUserEdit: boolean): Promise<PricingEntry>;
+    /**
+     * Apply a batch of entries fetched from a pricing source.
+     *
+     * userEdited-conflict semantics: rows that do not exist locally, or exist
+     * but are NOT user-edited, are upserted (source 'litellm', not user-edited)
+     * and returned in `applied`. Rows whose local copy IS user-edited MUST be
+     * left untouched and returned in `conflicts` as `{ current, incoming }`
+     * pairs for per-row resolution by the user.
+     */
+    bulkApplyFromSource(entries: PricingEntryInput[]): Promise<{
+        applied: PricingEntry[];
+        conflicts: Array<{
+            current: PricingEntry;
+            incoming: PricingEntryInput;
+        }>;
+    }>;
+    /**
+     * Apply per-row conflict decisions: 'overwrite' replaces the local row with
+     * the incoming values (clearing the user-edited mark), 'skip' leaves it
+     * unchanged. Returns overwritten/skipped counts.
+     */
+    applyResolutions(resolutions: Array<{
+        incoming: PricingEntryInput;
+        action: 'overwrite' | 'skip';
+    }>): Promise<PricingResolution>;
+}
+
+export type { PricingStore };

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

@@ -0,0 +1 @@
+"use strict";