@fayegram-ai/decision-bridge 0.1.0 → 0.1.1

package/CHANGELOG.md

@@ -2,6 +2,10 @@
 
 Notable user-facing changes by version.
 
+## 0.1.1
+
+- Add OpenAI `default`/`luna` selectors and requested/resolved model metadata; improve CLI configuration and documentation.
+
 ## 0.1.0
 
 Initial release of Decision Bridge as `@fayegram-ai/decision-bridge`.

package/README.md

@@ -29,7 +29,7 @@ embedded WAV/MP3 audio and MP4/WebM video, ordered images → audio → videos
 The common API checks provider/model capabilities before dispatch; refusals are
 errors.
 
-**Version 0.1.0 · Node.js 22.16+ or modern browsers (SDK) · ESM · zero runtime dependencies**
+**Version 0.1.1 · Node.js 22.16+ or modern browsers (SDK) · ESM · zero runtime dependencies**
 
 The npm package is
 [@fayegram-ai/decision-bridge](https://www.npmjs.com/package/@fayegram-ai/decision-bridge).
@@ -41,24 +41,30 @@ This is an independent project. The custom generative presets identify their
 probabilities as elicited model outputs.
 Changing providers does **not** make their accuracy or calibration equivalent.
 
-## Supported models
+## Model selectors
 
-The built-in decision providers support these model selectors in this release:
+Use these model selectors with the built-in decision providers:
 
-| Decision provider | Model selector | Accepted alias | Provider default |
-| --- | --- | --- | --- |
-| Jev through TypeSafe (`jev`) | `jev-latest` | — | `jev-latest` |
-| OpenAI Decisions (`openai-decisions`) | `gpt-6-luna` | — | `gpt-6-luna` |
-| Cloudflare (`cloudflare-decisions`) | `clef` | `@cf/cloudflare/clef` | `clef` |
-| Cloudflare (`cloudflare-decisions`) | `clef-flash` | `@cf/cloudflare/clef-flash` | — |
-| Cloudflare (`cloudflare-decisions`) | `clef-omni` | `@cf/cloudflare/clef-omni` | — |
+| Decision provider | Model selectors | Provider default |
+| --- | --- | --- |
+| Jev through TypeSafe (`jev`) | `jev-latest` | `jev-latest` |
+| OpenAI Decisions (`openai-decisions`) | `default`, `luna` | `default` |
+| Cloudflare (`cloudflare-decisions`) | `clef`, `@cf/cloudflare/clef` | `clef` |
+| Cloudflare (`cloudflare-decisions`) | `clef-flash`, `@cf/cloudflare/clef-flash` | — |
+| Cloudflare (`cloudflare-decisions`) | `clef-omni`, `@cf/cloudflare/clef-omni` | — |
 
 `jev-latest` is Jev's default alias. Jev also accepts explicit model IDs available through your TypeSafe account;
 use `bridge.listModels()` or the CLI `models` command to inspect that catalog.
 The bridge does not maintain a static list of Jev versions. A moving alias or a
 catalog entry does not guarantee inference access or reproducible model quality.
-OpenAI Decisions currently accepts only `gpt-6-luna` in this integration.
-Cloudflare accepts only the three models above, in short or full-alias form.
+For OpenAI Decisions, `default` selects the provider default and `luna` selects
+the supported Luna-family model. Decision Bridge resolves selectors to supported
+upstream model IDs before calling the service. Mappings are fixed by the installed
+Decision Bridge release. Explicit supported model IDs can also be selected; see
+the [OpenAI model selection guide](docs/guides/OPENAI_DECISIONS.md#model-selection)
+for details. Results retain the selected value in `meta.requestedModel`,
+the outgoing ID in `meta.resolvedModel`, and the service-reported model in `model`.
+Cloudflare accepts only the three models above, in short or full form.
 Model discovery is unsupported for OpenAI Decisions and Cloudflare.
 
 Additional decision protocols use [custom decision providers](docs/guides/CUSTOM_DECISION.md).

package/docs/README.md

@@ -7,8 +7,8 @@ Install `@fayegram-ai/decision-bridge` with npm; the
 [getting started guide](guides/GETTING_STARTED.md#install-into-your-application)
 also covers installation from a verified archive.
 The hosted playground is [Decision Playground](https://decision-pg.fayegram.com/).
-The root README lists [supported model selectors and aliases](../README.md#supported-models),
-including the distinction between built-in decision models and custom generative presets.
+See [model selectors and provider defaults](../README.md#model-selectors) for
+built-in decision models and the separate custom generative presets.
 
 Decision Bridge is a JavaScript SDK with an optional command runner. It evaluates
 supplied `state` or ordered `input`, plus `questions`, with an explicitly selected
@@ -27,7 +27,7 @@ the OpenAI and Cloudflare guides cover both.
 | [Browser integration](guides/BROWSER.md) | Direct browser use, CORS requirements, and credential exposure |
 | [Platforms](guides/PLATFORMS.md) | Windows, macOS, and Linux setup |
 | [Switching models](guides/SWITCHING_MODELS.md) | Backend and model selection |
-| [OpenAI Decisions](guides/OPENAI_DECISIONS.md) | Native/common decision access, ordered images, typed values, and capability checks |
+| [OpenAI Decisions](guides/OPENAI_DECISIONS.md) | Model selectors and upstream targets, selection metadata, common/native access, ordered images, and typed values |
 | [Cloudflare Clef / Clef-flash / Clef-omni](guides/CLOUDFLARE_DECISIONS.md) | Common/native decisions, embedded images and Omni audio/video, REST and Workers AI binding, busy-mode compatibility, and optional Gateway |
 | [Customization](guides/CUSTOMIZATION.md) | Questions, templates, extensions, and policies |
 | [Custom providers](guides/CUSTOM_PROVIDERS.md) | Common classified contract and explicit CLI module loading |

package/docs/development/ARCHITECTURE.md

@@ -5,7 +5,7 @@
 Decision Bridge exposes one application contract for structured decisions. The
 bridge owns request snapshots, common validation, extension sequencing, the total
 deadline, final result validation, immutable results, and bounded observations.
-A Provider owns its API encoding, transport, decoding, model defaults,
+A provider owns its API encoding, transport, decoding, model selection,
 capabilities, and native operations. Multiple models sharing a protocol can use
 one provider implementation.
 
@@ -46,6 +46,26 @@ shared evaluation deadline and extension lifecycle.
 Application policy decides whether a downstream action is permitted. The SDK
 returns decisions without executing actions or maintaining an agent loop.
 
+## Model selection and request preparation
+
+The bridge applies the provider's configured default when a request omits `model`.
+Its validated request and extension context retain that selected string. A provider
+may resolve a selection to an upstream ID while preparing its outgoing request;
+the shared provider contract has no selector-resolution hook.
+
+OpenAI's `openai-profile.mjs` owns the `default` selection, accepted selectors,
+upstream targets, and capabilities. Common and native preparation retain the
+validated selection separately from the resolved native request. Preflight returns
+the selected request, while serialization and byte-limit checks use the resolved
+request. Common evaluation and native `createDecision()` share dispatch, which
+sends only that resolved request.
+
+Successful OpenAI calls report the selected string in `meta.requestedModel` and
+the outgoing ID in `meta.resolvedModel`. The response's `model` retains the
+service-reported identity. CLI offline validation and execution use the same
+preflight, and generated OpenAI requests inherit selection from configuration.
+See [OpenAI model selection](../guides/OPENAI_DECISIONS.md#model-selection).
+
 ## Module map
 
 | Module | Responsibility |
@@ -61,6 +81,7 @@ returns decisions without executing actions or maintaining an agent loop.
 | `src/custom/generative/` | Opt-in protocol presets, schema, prompts, and result derivation |
 | `schemas/decision.config.schema.json` | Shipped CLI configuration structure and editor support |
 | `src/providers/` | API orchestration, model profiles, preflight, codecs, bounded image/audio/video inspection, and transports |
+| `src/providers/openai-profile.mjs`, `src/providers/decisions-preflight.mjs` | Release-owned OpenAI selection, capabilities, and preparation of selected and outgoing requests |
 | `src/embedded.mjs` | Shared embedded data URL and canonical base64 checks |
 | `src/transport.mjs`, `src/response-transport.mjs` | Credential destinations, bounded bodies, safe errors, retries |
 | `src/async.mjs` | Deadlines and cancellation races |

package/docs/development/DESIGN.md

@@ -43,6 +43,17 @@ Read JSON config only when named. Load custom ESM only when explicitly selected.
 Protect credential destinations and expose bounded callbacks. Consequence: plugins
 are powerful and must be trusted; cancellation is not a JavaScript sandbox.
 
+## Release-owned model selectors
+
+OpenAI Decisions offers `default` for the provider's default supported model and
+`luna` for the supported Luna-family model, alongside explicit supported upstream
+IDs. The installed package fixes the target and capability profile for each
+selector. The provider resolves it locally before serialization; no discovery,
+automatic upgrade, or fallback occurs during a call. Consequence: applications can
+use a stable selection string while inspecting selected, outgoing, and reported
+model identities separately. A future target change requires an intentional
+package update and verification of that model's protocol and capabilities.
+
 ## Conservative retries and independent observations
 
 Retry selected explicit transient HTTP statuses within a deadline. Do not retry

package/docs/development/TESTING.md

@@ -42,7 +42,7 @@ as evidence that every environment passed.
 - `transport.test.mjs`: HTTP policy, limits, retries, cancellation, and deadlines.
 - `deadlines.test.mjs`: synchronous preparation/dispatch/completion and inherited budgets.
 - `result-validation.test.mjs`: provider-selected precision and policy-hook boundaries.
-- `decisions*.test.mjs`: native/common OpenAI codecs, boundaries, preflight, CLI, and smoke-helper fixtures.
+- `decisions*.test.mjs`: native/common OpenAI codecs, selectors and model identities, boundaries, preflight, CLI, and smoke-helper fixtures.
 - `cloudflare*.test.mjs`: models, images, codecs, REST/binding/Gateway arguments, errors, and CLI limits.
 - `custom-providers.test.mjs`, `custom-config.test.mjs`: classified SDK paths, provenance, presets/modules, schema and initialization.
 - `generative-helpers.test.mjs`: exported prompt/normalization helper contracts and unsupported input rejection.
@@ -63,6 +63,28 @@ All model responses used by ordinary tests are synthetic. HTTP integration serve
 listen on loopback. Tests do not require account keys or make paid model calls.
 Test workspaces are temporary.
 
+### OpenAI model-selector coverage
+
+For changes to OpenAI selection or preparation, run the focused suites from the
+source root:
+
+```text
+node --test test/decisions-selectors.test.mjs test/decisions-preflight.test.mjs test/decisions-cli.test.mjs
+```
+
+These cover omitted, `default`, `luna`, and explicit upstream selection; unsupported
+and malformed values; independently selected, outgoing, and reported identities;
+capabilities and extension context; immutable input; SDK batch preflight; resolved
+wire-byte limits; CLI precedence and mixed-selector rows; and generated requests
+that inherit later configuration changes. Existing Decisions suites also cover
+revalidation after input preparation, refusals, retries, and deadlines.
+
+Type and installed-package checks exercise metadata declarations, SDK/CLI
+selection, and browser execution without Node globals. Use `npm run verify` for
+the complete integration check. A selector mapping change must be verified against
+the target model's protocol and capabilities; local fixtures alone do not establish
+compatibility with a newly selected upstream model.
+
 ## Optional authenticated provider smoke check
 
 Live inference is explicitly opted in and can incur charges. Configure credentials

package/docs/guides/CLOUDFLARE_DECISIONS.md

@@ -4,8 +4,8 @@ Use `cloudflare-decisions` for hosted inference with `clef` (the default),
 `clef-flash`, or `clef-omni`. All three support common bridge requests and the
 dedicated native API. Each accepts its full `@cf/cloudflare/<model>` alias.
 The provider normalizes the endpoint identifier and the required input selector together.
-See the root README's [model list](../../README.md#supported-models) for the exact
-short selectors and full aliases.
+See the [model selector inventory](../../README.md#model-selectors) for supported
+short selectors and full forms.
 
 | Model | Hosted context, in tokens | Default client request budget | Media |
 | --- | ---: | ---: | --- |

package/docs/guides/CUSTOM_PROVIDERS.md

@@ -17,7 +17,7 @@ extension path.
 `Provider` requires a nonempty `name`, explicit `kind: 'decision' | 'generative'`,
 and `evaluate(request, { signal? })`. Optional fields and hooks are:
 
-- `defaultModel`: a nonempty model ID, otherwise the request must supply one.
+- `defaultModel`: a nonempty selection string, otherwise the request must supply one.
 - `probabilitySource`: known provenance; generative providers use `elicited`.
 - `getCapabilities(model)`: a pure synchronous capability profile.
 - `validateRequest(request)`: pure synchronous provider preflight; no inference.
@@ -31,7 +31,9 @@ that implement this contract directly. Missing or invalid kinds fail at construc
 `bridge.providerKind` and `result.meta.providerKind` come from the contract and
 cannot be overridden by response metadata.
 
-The request is already snapshotted, validated, resolved to a model, and frozen.
+The request is already snapshotted, validated, supplied with an effective model
+selection, and frozen. Its model string retains the selection; any mapping to an
+upstream ID belongs to the provider's preparation and transport.
 Return canonical `{ model, answers, usage, meta? }`; the bridge validates and
 freezes the result. Custom providers own API encoding, transport, response mapping,
 credential destinations, bounded bodies, safe errors, and cancellation cleanup.

package/docs/guides/GETTING_STARTED.md

@@ -25,7 +25,7 @@ You can also install a verified local archive, replacing the path below. See
 a source checkout:
 
 ```bash
-npm install /path/to/fayegram-ai-decision-bridge-0.1.0.tgz
+npm install /path/to/fayegram-ai-decision-bridge-0.1.1.tgz
 ```
 
 The installed package contains the SDK, declarations, command runner, examples,

package/docs/guides/OPENAI_DECISIONS.md

@@ -1,13 +1,50 @@
 # OpenAI Decisions
 
-The `openai-decisions` provider implements the native `POST /v1/decisions` API,
-supporting `gpt-6-luna` as its default and only accepted model in this release.
+The `openai-decisions` provider implements the native `POST /v1/decisions` API.
+Its default model selector is `default`; `luna` selects the supported Luna-family
+model, and `gpt-6-luna` selects that explicit upstream ID. Decision Bridge resolves
+all three selections to `gpt-6-luna` in this release before calling the service.
 This integration follows the official [Decisions guide](https://developers.openai.com/api/docs/guides/decisions)
 and [API reference](https://developers.openai.com/api/reference/resources/decisions/methods/create).
 Account access and remote limits still apply. Unknown models fail locally with
 `UNSUPPORTED_CAPABILITY`. The opt-in `openai-compatible` preset in `custom/generative` continues
 using Chat Completions.
 
+## Model selection
+
+```javascript
+import { createProvider } from '@fayegram-ai/decision-bridge';
+
+createProvider({ type: 'openai-decisions' }); // Selects default.
+createProvider({ type: 'openai-decisions', model: 'luna' });
+createProvider({ type: 'openai-decisions', model: 'gpt-6-luna' });
+```
+
+These are alternative configurations. An omitted request `model` inherits the
+provider's configured selection; an explicit request `model` overrides it.
+With no provider or request model configured, the selection is `default`:
+
+| Selection | Selected value | Current upstream target |
+| --- | --- | --- |
+| Omitted, with no configured model | `default` | `gpt-6-luna` |
+| `default` | `default` | `gpt-6-luna` |
+| `luna` | `luna` | `gpt-6-luna` |
+| `gpt-6-luna` | `gpt-6-luna` | `gpt-6-luna` |
+
+Mappings are fixed by the installed Decision Bridge release; there is
+no runtime model discovery, automatic upgrading, or fallback after failure.
+The `default` selector follows the provider default, while `luna` stays within
+the Luna family. The resolved upstream model must have a supported capability
+profile before a selector can target it.
+
+`provider.defaultModel` and `bridge.defaultModel` expose the configured selection,
+using `default` when provider configuration omits `model`. Validated requests and
+extension context retain the effective selected value. Successful common
+and native calls expose `meta.requestedModel` for that selection and
+`meta.resolvedModel` for the upstream ID sent. The common `result.model` and native
+`decision.model` preserve the service-reported identity, which may differ from
+the outgoing ID. Byte limits apply to the resolved wire request.
+
 ## Common bridge access
 
 Set `OPENAI_API_KEY` in the process environment:
@@ -141,14 +178,15 @@ const { decision, meta } = await provider.createDecision({
 }, { signal: controller.signal });
 ```
 
-An omitted model resolves to the provider default. Native input accepts text or
+An omitted model inherits the provider's configured selection. Native input accepts text or
 multiple user messages containing text or ordered `input_text`/`input_image`
 parts. Only user roles are supported. Files, external image URLs, audio, tools,
 and item references are rejected locally. Exported `NativeDecisionRequest` and
 related types describe this format.
 
 `decision` preserves native answer arrays, optional question names, probabilities,
-confidence, and full usage. `meta` contains transport duration, attempt count,
+confidence, and full usage. `meta` has the exported `OpenAIDecisionsTransportMetadata`
+shape: requested/resolved model identities, transport duration, attempt count,
 and request ID when available. Results are immutable. This method bypasses
 common bridge extensions.
 
@@ -197,6 +235,10 @@ provider. Native evaluation/validation/batch require an explicit file or `-`.
 Mode is never inferred from JSON. Initialization writes a native request, which
 must still be evaluated with `--native`. Offline validation checks built-in
 capabilities without credentials; custom capabilities are checked at evaluation.
+OpenAI initialization stores the model selection in configuration and omits it
+from the generated request so later configuration changes apply. The default
+configuration uses `default`. Offline validation reports the selected value as
+`model` and the outgoing upstream ID as `resolvedModel`.
 Decisions offline validation also checks native field limits and the configured
 request byte limit in both modes.
 

package/docs/guides/PLATFORMS.md

@@ -22,7 +22,7 @@ compatible native Node runtime. See [testing](../development/TESTING.md).
 Open PowerShell at the cloned repository or extracted source directory:
 
 ```powershell
-cd "C:\path\to\decision-bridge-0.1.0"
+cd "C:\path\to\decision-bridge-0.1.1"
 node --version
 node bin/decision.mjs validate examples/request.json
 Copy-Item .env.example .env
@@ -48,7 +48,7 @@ the archive rather than reusing generated `node_modules` or executable shims.
 ## macOS / Linux
 
 ```bash
-cd "/path/to/decision-bridge-0.1.0"
+cd "/path/to/decision-bridge-0.1.1"
 node --version
 node bin/decision.mjs validate examples/request.json
 cp .env.example .env

package/docs/guides/SWITCHING_MODELS.md

@@ -4,7 +4,7 @@ The bridge's request contains `questions`, either `state` or ordered `input`, an
 optionally `model`. Ordered input and richer question types require provider capabilities.
 The provider translates it into that service's wire protocol and validates the
 response. Select a provider when constructing your SDK bridge.
-The root README lists [supported model selectors and aliases](../../README.md#supported-models).
+See [model selectors and provider defaults](../../README.md#model-selectors).
 
 ## Native and custom selection
 
@@ -72,7 +72,7 @@ example and provide that backend's credential in `.env`:
 | Native SDK `createProvider` type | Credential variable | Model selection |
 | --- | --- | --- |
 | `jev` | `TYPESAFE_API_KEY` | Defaults to `jev-latest`; an explicit model overrides it |
-| `openai-decisions` | `OPENAI_API_KEY` | Defaults to `gpt-6-luna` |
+| `openai-decisions` | `OPENAI_API_KEY` | Defaults to `default`; also accepts `luna` and explicit `gpt-6-luna` |
 | `cloudflare-decisions` | `CLOUDFLARE_API_TOKEN` and `CLOUDFLARE_ACCOUNT_ID` for REST | Defaults to `clef`; also supports `clef-flash` and `clef-omni` |
 
 Custom generative presets use `createGenerativeProvider` instead. Their types are
@@ -83,7 +83,7 @@ using the following native alternatives:
 
 ```javascript
 createProvider({ type: 'jev', model: 'jev-latest' });
-createProvider({ type: 'openai-decisions', model: 'gpt-6-luna' });
+createProvider({ type: 'openai-decisions', model: 'luna' });
 createProvider({ type: 'cloudflare-decisions', model: 'clef-flash' });
 createGenerativeProvider({ type: 'openai-compatible', model: process.env.DECISION_MODEL });
 createGenerativeProvider({ type: 'anthropic', model: process.env.DECISION_MODEL });
@@ -96,6 +96,12 @@ The SDK does not automatically read `DECISION_*` settings: this example passes
 `process.env.DECISION_MODEL` explicitly. The SDK factory property is **`type`**;
 a command-runner JSON profile uses **`provider`**.
 
+OpenAI's `default` selector chooses the provider default and `luna` chooses the
+supported Luna-family model. Both currently resolve to upstream `gpt-6-luna`
+through Decision Bridge. Use `model: 'gpt-6-luna'` to select that explicit upstream
+ID. Mappings are fixed by the installed package release; results expose the
+selection in `meta.requestedModel` and outgoing ID in `meta.resolvedModel`.
+
 For Jev and the generative providers, list models with `await bridge.listModels()`.
 OpenAI Decisions and Cloudflare Clef do not implement model discovery and return
 `UNSUPPORTED_OPERATION`; their capability profiles do not prove account availability.
@@ -143,7 +149,7 @@ uppercase model placeholders with IDs available to your account/server:
 
 ```bash
 npm exec -- decision-bridge evaluate ./my-decisions/request.json --provider jev --model jev-latest --env-file .env
-npm exec -- decision-bridge evaluate ./my-decisions/request.json --provider openai-decisions --model gpt-6-luna --env-file .env
+npm exec -- decision-bridge evaluate ./my-decisions/request.json --provider openai-decisions --model default --env-file .env
 npm exec -- decision-bridge evaluate ./my-decisions/request.json --provider cloudflare-decisions --model clef-flash --env-file .env
 npm exec -- decision-bridge evaluate ./my-decisions/request.json --provider custom-generative --preset openrouter --model VENDOR/MODEL_ID --env-file .env
 npm exec -- decision-bridge evaluate ./my-decisions/request.json --provider custom-generative --preset openai-compatible --model MODEL_ID --env-file .env

package/docs/guides/TROUBLESHOOTING.md

@@ -18,6 +18,20 @@ explicit config. A compatible base includes its version prefix, not the final
 `/chat/completions` path. Jev and the custom Anthropic preset require origins
 without a path. See [configuration](../reference/CONFIGURATION.md#precedence).
 
+## OpenAI reports a versioned model after I select default or luna
+
+`default` and `luna` are Decision Bridge model selectors. Both currently resolve
+to `gpt-6-luna`, which is the upstream ID sent to OpenAI. Successful common and
+native calls expose the selection as `meta.requestedModel` and the outgoing ID
+as `meta.resolvedModel`. `result.model` or native `decision.model` preserves the
+service-reported identity, which may differ from the outgoing ID.
+
+An omitted request model inherits the configured model. OpenAI initialization
+omits `model` from its generated requests so later configuration edits apply.
+If selection fails with `UNSUPPORTED_CAPABILITY`, check the
+[accepted selectors](OPENAI_DECISIONS.md#model-selection); the bridge does not
+discover another model or fall back after failure.
+
 ## Structured output is rejected
 
 Check that the selected endpoint/model supports the requested `json_schema` mode.

package/docs/reference/CLI.md

@@ -20,8 +20,9 @@ it with `node bin/decision.mjs` from a source checkout. `decision` and
 The CLI defaults to Jev. Flags override `DECISION_*` environment settings, which
 override an explicit config file and then built-in defaults. It constructs an
 explicit provider for the SDK; `createBridge` itself has no implicit selection.
-Use the root README's [model list](../../README.md#supported-models) to select a
-supported native model. Custom generative presets require an explicit model ID.
+Choose a supported native model from the
+[model selector inventory](../../README.md#model-selectors).
+Custom generative presets require an explicit model ID.
 
 ## Commands
 
@@ -32,6 +33,12 @@ for native request/response structures on `init`, `evaluate`, `validate`, or
 or `-`. See [OpenAI Decisions](../guides/OPENAI_DECISIONS.md) and
 [Cloudflare Clef](../guides/CLOUDFLARE_DECISIONS.md) for examples. Both providers report
 model listing as unsupported.
+OpenAI model selection defaults to `default`; use `--model luna` for the Luna
+family or an explicit supported upstream ID. Both stable selectors currently
+resolve to `gpt-6-luna` within Decision Bridge. OpenAI `validate` reports the
+selected value in `model` and the outgoing ID in `resolvedModel`, without credentials.
+Successful common and native calls include `meta.requestedModel` and
+`meta.resolvedModel`; response models retain the service-reported identity.
 Cloudflare CLI execution uses REST. The Workers AI binding is an SDK transport;
 there is no CLI binding selector. Gateway settings route the selected REST request.
 
@@ -71,6 +78,10 @@ explicit service implementation error until you connect it. An existing
 `--provider-module` is referenced without execution or overwrite. All profiles
 include a copied JSON Schema for editor validation. See [custom providers](../guides/CUSTOM_PROVIDERS.md).
 
+OpenAI initialization writes the selected model into configuration, using `default`
+when omitted. Its generated common and native requests omit `model`, allowing
+later configuration changes to control selection.
+
 ## Flags
 
 | Flag | Meaning |
@@ -80,7 +91,7 @@ include a copied JSON Schema for editor validation. See [custom providers](../gu
 | `--provider NAME` | `jev`, `openai-decisions`, `cloudflare-decisions`, `custom-decision`, `custom-generative` |
 | `--preset NAME` | custom-generative preset: `openai-compatible`, `openrouter`, or `anthropic`; exclusive with module |
 | `--native` | Explicit native Decisions input/output; init/evaluate/validate/batch only |
-| `--model ID` | Overrides input JSON model and provider default |
+| `--model SELECTOR` | Model selector or supported upstream ID; overrides input JSON model and configured default |
 | `--base-url URL` | Custom endpoint; requires explicit credential selection |
 | `--api-key-env NAME` | Environment variable name, never the key itself |
 | `--account-id ID` | Cloudflare REST account ID |

package/docs/reference/CONFIGURATION.md

@@ -40,7 +40,7 @@ profile. Gateway configuration is optional for either SDK transport and for CLI
 | `schemaVersion` | 1; optional, but generated profiles include it |
 | `provider` | `jev` default, `openai-decisions`, `cloudflare-decisions`, `custom-decision`, `custom-generative` |
 | `preset` | `custom-generative` only: `openai-compatible`, `openrouter`, `anthropic`; mutually exclusive with module |
-| `model` | Nonempty model ID; built-in native providers have defaults; required for generative evaluation unless the request supplies it |
+| `model` | Nonempty model selector or supported upstream ID; built-in native providers have defaults; required for generative evaluation unless the request supplies it |
 | `baseURL` | HTTPS API base; loopback may use HTTP |
 | `apiKeyEnv` | Credential environment variable name; inline `apiKey` is rejected |
 | `noAuth` | Boolean; true only for loopback OpenAI-compatible endpoints |
@@ -88,8 +88,8 @@ existing process environment > --env-file values
 The loader does not mutate the process environment. The SDK independently reads
 its documented ambient credential variables at provider construction.
 
-The [supported-model list](../../README.md#supported-models) records native
-selectors, aliases and defaults. Configuration precedence does not expand a
+The [model selector list](../../README.md#model-selectors) records native
+selectors and defaults. Configuration precedence does not expand a
 provider's accepted models or grant account access.
 
 For evaluation model selection:
@@ -99,7 +99,9 @@ For evaluation model selection:
 ```
 
 Jev defaults to `jev-latest`, with `JEV_MODEL` as a legacy/direct convenience.
-Native OpenAI Decisions defaults to `gpt-6-luna`; it accepts transport settings
+Native OpenAI Decisions defaults to `default` and accepts `luna` or explicit
+`gpt-6-luna`; Decision Bridge currently resolves each to upstream `gpt-6-luna`.
+OpenAI accepts transport settings
 and rejects generative output settings. Its default retry count is zero. Cloudflare Clef defaults to `clef`, uses
 account/token credentials, rejects generation settings, and also defaults to zero retries.
 A `DECISION_MODEL` or file model takes precedence over that convenience.

package/docs/reference/ERRORS.md

@@ -77,6 +77,9 @@ validation failures can still return HTTP 422/5012 and retain safe diagnostics.
 Keep the default disabled setting for ordinary REST
 inference; see the [Cloudflare guide](../guides/CLOUDFLARE_DECISIONS.md#capacity-rejection-and-ai-gateway).
 
-Keep a request ID and available Gateway log ID, bridge version, configured provider, requested/reported model,
-and template revision for incident analysis. Log input or results only under your
+Keep a request ID and available Gateway log ID, bridge version, configured provider,
+model selection, reported model, and template revision for incident analysis.
+For successful OpenAI calls, retain
+the requested selection, resolved outgoing ID, and reported model separately;
+see [model identities](../guides/OPENAI_DECISIONS.md#model-selection). Log input or results only under your
 own data-handling policy. No logging or telemetry is enabled by default.

package/docs/reference/PROVIDERS.md

@@ -2,10 +2,10 @@
 
 ## Native routes
 
-| Provider type | Wire API | Credential | Default model | Output strategy |
+| Provider type | Wire API | Credential | Default selector | Output strategy |
 | --- | --- | --- | --- | --- |
 | `jev` | `POST /v1/systemone` at api.typesafe.ai | `TYPESAFE_API_KEY` | `jev-latest` | Native typed decisions |
-| `openai-decisions` | `POST /v1/decisions` at api.openai.com | `OPENAI_API_KEY` | `gpt-6-luna` | Native Decisions with common and dedicated access |
+| `openai-decisions` | `POST /v1/decisions` at api.openai.com | `OPENAI_API_KEY` | `default` | Native Decisions with common and dedicated access |
 | `cloudflare-decisions` | Workers AI REST model route or `AI.run` binding | `CLOUDFLARE_API_TOKEN` and account ID for REST | `clef` | Native Clef decisions with common and dedicated access |
 
 `createProvider()` and the root SDK export these three native providers only.
@@ -15,9 +15,12 @@ maintained, but are not native decision models. See [custom providers](../guides
 
 ## Supported model selection
 
-See the root README's [model list](../../README.md#supported-models) for the
-built-in selectors and aliases. Jev accepts `jev-latest` and explicit Jev IDs from
-its account catalog. OpenAI Decisions supports only `gpt-6-luna` in this release.
+The [model selector inventory](../../README.md#model-selectors) summarizes the
+built-in providers. Jev accepts `jev-latest` and explicit Jev IDs from
+its account catalog. OpenAI Decisions accepts `default`, `luna`, and explicit
+`gpt-6-luna`. Decision Bridge resolves these to the upstream `gpt-6-luna` model
+in this release. The selected value remains in `meta.requestedModel`, the outgoing
+ID in `meta.resolvedModel`, and the service-reported identity in the response's `model`.
 Cloudflare supports `clef`, `clef-flash`, and `clef-omni`, including each full
 `@cf/cloudflare/<model>` alias. Unsupported OpenAI/Cloudflare selectors fail
 local preflight with `UNSUPPORTED_CAPABILITY`.

package/docs/reference/SDK.md

@@ -72,7 +72,10 @@ they interact; [errors](ERRORS.md#retry-policy) lists retryable statuses.
 `model` and `safetyIdentifier`. New forms require declared provider capabilities;
 see [OpenAI Decisions](../guides/OPENAI_DECISIONS.md) and
 [Cloudflare Clef](../guides/CLOUDFLARE_DECISIONS.md). The request model
-wins over the provider's default. No default is assumed for a generative provider.
+wins over the provider's configured default, which an omitted request model inherits.
+OpenAI Decisions uses the `default` selector when its provider configuration omits
+`model`; `luna` and explicit `gpt-6-luna` are also supported. Its selectors
+resolve to upstream IDs within the provider. No default is assumed for a generative provider.
 `options` accepts `signal: AbortSignal` and `timeoutMs`, overriding the bridge's
 60-second evaluation budget for this call. It does not mutate the provider's
 independent transport timeout, including Workers AI binding calls.
@@ -92,10 +95,12 @@ when client retries are configured.
 ### `bridge.getCapabilities(model?)` and `bridge.validate(request)`
 
 Capability lookup is synchronous and reports implemented features and limits.
-`validate` resolves the model, snapshots/freezes the request, and checks capabilities
+`validate` applies the default model selection, snapshots/freezes the request, and checks capabilities
 and preparation-extension compatibility without inference. Unsupported features
 fail with `UNSUPPORTED_CAPABILITY` before dispatch. Native Decisions has no model
 listing operation; capability lookup is not account model discovery.
+OpenAI validated requests retain the selected value, while preflight checks the
+resolved outgoing request, including its model ID, against the byte limit.
 
 Providers can implement optional `validateRequest(resolvedRequest)` for additional
 static checks. This synchronous hook receives a frozen request, must return no
@@ -207,7 +212,8 @@ estimated token count is fabricated.
 | --- | --- |
 | `provider` | Bridge backend name; native Jev reports `typesafe` |
 | `providerKind` | `decision` or `generative`; authoritative provider classification, never response-selected |
-| `requestedModel` | Resolved model requested by the caller |
+| `requestedModel` | Selected model after applying the provider default; OpenAI retains `default`, `luna`, or the explicit ID |
+| `resolvedModel` | Upstream model ID sent by OpenAI Decisions; optional for other providers |
 | `probabilitySource` | `native`, `elicited`, or custom/`unspecified` provenance |
 | `confidenceSource` | `native` or `unavailable` for built-in providers |
 | `modelSource` | `reported` or `requested` fallback for built-in providers |

package/examples/configs/openai-decisions.json

@@ -1,7 +1,7 @@
 {
     "schemaVersion": 1,
     "provider": "openai-decisions",
-    "model": "gpt-6-luna",
+    "model": "default",
     "apiKeyEnv": "OPENAI_API_KEY",
     "maxRetries": 0
 }

package/examples/decisions.native.json

@@ -1,5 +1,5 @@
 {
-    "model": "gpt-6-luna",
+    "model": "default",
     "input": "Export fails in Safari but works in Chrome.",
     "questions": [
         { "type": "predicate", "name": "browser_specific", "instructions": "Is the failure browser-specific?" },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fayegram-ai/decision-bridge",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "JavaScript SDK and CLI for structured decisions across native decision APIs and configurable model providers",
   "repository": {
     "type": "git",

package/src/capabilities.mjs

@@ -1,6 +1,7 @@
 import { DecisionError, requireCondition as check } from './errors.mjs';
 import { cloneJson, freezeJson, isRecord } from './validation.mjs';
 import { CLOUDFLARE_MODELS } from './providers/cloudflare-profile.mjs';
+import { openaiModelProfile } from './providers/openai-profile.mjs';
 
 /** Conservative defaults preserve the pre-existing custom-provider contract. */
 export const LEGACY_CAPABILITIES = freezeJson({
@@ -9,11 +10,6 @@ export const LEGACY_CAPABILITIES = freezeJson({
     maxImages: 0, maxChoiceOptions: 255, maxScoreLevels: 10,
     audio: false, videos: false, maxAudioClips: 0, maxVideos: 0,
 });
-const OPENAI_CAPABILITIES = freezeJson({
-    supported: true, orderedInput: true, images: true, typedChoices: true,
-    labeledScores: true, safetyIdentifier: true,
-    maxImages: 128, maxChoiceOptions: 255, maxScoreLevels: null,
-});
 
 const CLOUDFLARE_CAPABILITIES = freezeJson({
     supported: true, orderedInput: true, images: true, typedChoices: true,
@@ -29,7 +25,8 @@ export function builtInCapabilities(type, model) {
             maxAudioClips: profile?.omni ? 4 : 0, maxVideos: profile?.omni ? 2 : 0 });
     }
     if (type !== 'openai-decisions') return LEGACY_CAPABILITIES;
-    return freezeJson({ ...LEGACY_CAPABILITIES, ...OPENAI_CAPABILITIES, supported: model === 'gpt-6-luna' });
+    const profile = openaiModelProfile(model);
+    return freezeJson({ ...LEGACY_CAPABILITIES, ...profile, supported: !!profile });
 }
 
 export function providerCapabilities(provider, model) {

package/src/cli/config.mjs

@@ -1,6 +1,7 @@
 import { readFile, stat } from 'node:fs/promises';
 import { resolve, dirname } from 'node:path';
 import { parseEnv } from 'node:util';
+import { OPENAI_DEFAULT_MODEL } from '../providers/openai-profile.mjs';
 import { DecisionError, requireCondition as check } from '../errors.mjs';
 import { validateConfig, NUMERIC, PROVIDER_FIELDS } from './config-validation.mjs';
 export { validateConfig } from './config-validation.mjs';
@@ -78,7 +79,7 @@ export async function loadConfig({ configPath, envFile, overrides = {}, cwd = pr
   if (config.provider === 'jev' && config.model === undefined && effectiveEnv.JEV_MODEL?.trim()) {
     config.model = effectiveEnv.JEV_MODEL.trim();
   }
-  if (config.provider === 'openai-decisions' && config.model === undefined) config.model = 'gpt-6-luna';
+  if (config.provider === 'openai-decisions' && config.model === undefined) config.model = OPENAI_DEFAULT_MODEL;
   if (config.provider === 'cloudflare-decisions' && config.model === undefined) config.model = 'clef';
   return { config, env: effectiveEnv, moduleBase };
 }

package/src/cli/decisions.mjs

@@ -3,11 +3,13 @@ import { encodeCommonDecision } from '../providers/decisions-codec.mjs';
 import { preflightCloudflareDecision, preflightCommonCloudflareDecision } from '../providers/cloudflare-preflight.mjs';
 import { encodeCloudflareDecision } from '../providers/cloudflare-codec.mjs';
 import { CLOUDFLARE_MAX_REQUEST_LIMIT } from '../providers/cloudflare-profile.mjs';
+import { resolveOpenAIModel } from '../providers/openai-profile.mjs';
 
 /** Provider-specific native dispatch is shared by validation, initialization and calls. */
 export function decisionProfile(provider) {
     if (provider === 'openai-decisions') return {
         common: preflightCommonDecision, native: preflightDecision, encode: encodeCommonDecision,
+        resolveModel: resolveOpenAIModel,
         options: config => ({ model: config.model, maxRequestBytes: config.maxRequestBytes }),
     };
     if (provider === 'cloudflare-decisions') return {

package/src/cli/initialize.mjs

@@ -4,6 +4,7 @@ import { DecisionError } from '../errors.mjs';
 import { validateRequest } from '../validation.mjs';
 import { decisionProfile } from './decisions.mjs';
 import { validateConfig, KEY_ENVS } from './config-validation.mjs';
+import { OPENAI_DEFAULT_MODEL } from '../providers/openai-profile.mjs';
 
 /** Templates are honest edit points for an unknown protocol, never fake inference. */
 function providerTemplate(kind) {
@@ -38,6 +39,7 @@ export async function initialize(directory, config, native = false, moduleBase =
         ...(generateModule ? { module: './provider.mjs' } : {}),
         ...(config.module ? { module: resolve(moduleBase, config.module) } : {}),
         ...(config.provider === 'jev' && config.model === undefined ? { model: 'jev-latest' } : {}),
+        ...(config.provider === 'openai-decisions' && config.model === undefined ? { model: OPENAI_DEFAULT_MODEL } : {}),
         ...(custom && config.model === undefined ? { model: 'YOUR_MODEL' } : {}),
     }, { complete: true });
     const request = { state: "ModuleNotFoundError: No module named 'pytest'", questions: {
@@ -47,12 +49,16 @@ export async function initialize(directory, config, native = false, moduleBase =
         missing_dependency: { type: 'noul', instructions: 'Does this indicate a missing Python package?' },
     } };
     const profile = decisionProfile(config.provider);
+    const sample = native ? profile.native(profile.encode(validateRequest(request, template.model)),
+        profile.options(template)) : request;
+    // OpenAI request files inherit selection from configuration, including after later edits.
+    const generated = { ...sample };
+    if (config.provider === 'openai-decisions') delete generated.model;
     const schema = await readFile(new URL('../../schemas/decision.config.schema.json', import.meta.url), 'utf8');
     const files = {
         'decision.config.json': JSON.stringify(template, null, 2) + '\n',
         'decision.config.schema.json': schema,
-        'request.json': JSON.stringify(native ? profile.native(profile.encode(validateRequest(request, template.model)),
-            profile.options(template)) : request, null, 2) + '\n',
+        'request.json': JSON.stringify(generated, null, 2) + '\n',
         '.env.example': `${template.apiKeyEnv}=replace_with_your_api_key\n` +
             (config.provider === 'cloudflare-decisions' ? 'CLOUDFLARE_ACCOUNT_ID=replace_with_your_account_id\n' : ''),
         '.gitignore': '.env\n.env.*\n!.env.example\nnode_modules/\n*.tmp\n',

package/src/cli/main.mjs

@@ -214,6 +214,7 @@ export async function runCli(argv, { stdin = process.stdin, stdout = process.std
         ? (await import('../custom/generative/schema.mjs')).buildResponseSchema : undefined;
       await writeJson(command === 'schema' ? buildResponseSchema(request.questions)
         : { valid: true, validationScope: isModule(loaded.config) ? 'structure' : 'provider', questionCount: Object.keys(request.questions).length, model: selectedModel,
+          ...(profile?.resolveModel ? { resolvedModel: profile.resolveModel(request.model) } : {}),
           ...(values.native ? { native: true } : {}) });
     } else {
       let request;

package/src/decisions.d.mts

@@ -39,6 +39,11 @@ export interface OpenAIDecisionResponse {
 export interface TransportMetadata {
     readonly attempts: number; readonly durationMs: number; readonly requestId?: string;
 }
+/** Selected model, resolved outgoing ID, and transport diagnostics for native calls. */
+export interface OpenAIDecisionsTransportMetadata extends TransportMetadata {
+    readonly requestedModel: string;
+    readonly resolvedModel: string;
+}
 export type OpenAIDecisionsMetadata = {
     readonly usage: OpenAIDecisionUsage;
     readonly answers: Readonly<Record<string, { readonly type: 'predicate' | 'choice' | 'score'; readonly confidence?: number }>>;

package/src/index.d.mts

@@ -1,8 +1,9 @@
 /** JSON values are read-only because the bridge snapshots/freezes its boundaries. */
 import type { NativeDecisionRequest, OpenAIDecisionResponse, OpenAIDecisionUsage,
-    OpenAIDecisionsMetadata, TransportMetadata } from './decisions.d.mts';
+    OpenAIDecisionsMetadata, OpenAIDecisionsTransportMetadata } from './decisions.d.mts';
 export type { NativeDecisionInputPart, NativeDecisionMessage, NativeDecisionQuestion, NativeDecisionRequest,
-    NativeDecisionAnswer, OpenAIDecisionResponse, OpenAIDecisionUsage, OpenAIDecisionsMetadata, TransportMetadata } from './decisions.d.mts';
+    NativeDecisionAnswer, OpenAIDecisionResponse, OpenAIDecisionUsage, OpenAIDecisionsMetadata,
+    OpenAIDecisionsTransportMetadata, TransportMetadata } from './decisions.d.mts';
 import type { CloudflareDecisionsOptions, CloudflareDecisionRequest, CloudflareDecisionResponse,
     CloudflareTransportMetadata, CloudflareDecisionsMetadata } from './cloudflare-decisions.d.mts';
 export type { CloudflareDecisionModel, CloudflareDecisionImage, CloudflareDecisionAudio, CloudflareDecisionVideo,
@@ -88,6 +89,8 @@ export interface ProviderResult<Q extends Questions = Questions> {
 }
 export interface Metadata {
   readonly provider: string; readonly providerKind: ProviderKind; readonly requestedModel: string;
+  /** Upstream model ID sent after provider selection, when supplied by the provider. */
+  readonly resolvedModel?: string;
   readonly probabilitySource: 'native' | 'elicited' | 'unspecified' | (string & {});
   readonly confidenceSource?: 'native' | 'unavailable' | (string & {});
   readonly modelSource?: 'reported' | 'requested';
@@ -171,7 +174,7 @@ export class OpenAIDecisionsProvider implements DecisionProvider {
     validateRequest(request: ResolvedRequest): void;
     evaluate<const Q extends Questions>(request: EvaluationRequest<Q>, options?: ProviderCallOptions): Promise<ProviderResult<Q>>;
     createDecision(request: NativeDecisionRequest, options?: ProviderCallOptions):
-        Promise<{ readonly decision: OpenAIDecisionResponse; readonly meta: TransportMetadata }>;
+        Promise<{ readonly decision: OpenAIDecisionResponse; readonly meta: OpenAIDecisionsTransportMetadata }>;
 }
 export class CloudflareDecisionsProvider implements DecisionProvider {
     readonly kind: 'decision'; readonly name: 'cloudflare-decisions'; readonly probabilitySource: 'native'; readonly defaultModel: string;

package/src/providers/decisions-preflight.mjs

@@ -4,17 +4,28 @@ import { assertCapabilities, builtInCapabilities } from '../capabilities.mjs';
 import { serializeRequestBody } from '../transport.mjs';
 import { validateDecisionRequest } from './decisions-validation.mjs';
 import { encodeCommonDecision } from './decisions-codec.mjs';
+import { OPENAI_DEFAULT_MODEL, resolveOpenAIModel } from './openai-profile.mjs';
 
-export function preflightDecision(input, { model = 'gpt-6-luna', maxRequestBytes } = {}) {
+/** Keep the caller selection separate from the resolved, size-checked wire request. */
+export function prepareDecision(input, { model = OPENAI_DEFAULT_MODEL, maxRequestBytes } = {}) {
     const request = validateDecisionRequest(input, model);
-    serializeRequestBody(request, maxRequestBytes);
-    return request;
+    const native = freezeJson({ ...request, model: resolveOpenAIModel(request.model) });
+    serializeRequestBody(native, maxRequestBytes);
+    return { request, native };
+}
+
+export function preflightDecision(input, options = {}) {
+    return prepareDecision(input, options).request;
 }
 
 /** Check converted JSON text and wire bytes, not just the common request shape. */
-export function preflightCommonDecision(input, options = {}) {
-    const request = validateRequest(input, options.model ?? 'gpt-6-luna');
+export function prepareCommonDecision(input, options = {}) {
+    const request = validateRequest(input, options.model ?? OPENAI_DEFAULT_MODEL);
     assertCapabilities(request, builtInCapabilities('openai-decisions', request.model));
-    preflightDecision(encodeCommonDecision(request), options);
-    return freezeJson(request);
+    const { native } = prepareDecision(encodeCommonDecision(request), options);
+    return { request: freezeJson(request), native };
+}
+
+export function preflightCommonDecision(input, options = {}) {
+    return prepareCommonDecision(input, options).request;
 }

package/src/providers/decisions-validation.mjs

@@ -2,6 +2,7 @@ import { DecisionError, requireCondition as check } from '../errors.mjs';
 import { cloneJson, freezeJson, isRecord } from '../validation.mjs';
 import { isTextWithinLimit, validateImage } from '../input.mjs';
 import { builtInCapabilities } from '../capabilities.mjs';
+import { OPENAI_DEFAULT_MODEL } from './openai-profile.mjs';
 
 const own = (value, key) => Object.hasOwn(value, key);
 function fields(value, allowed, required, label, code = 'VALIDATION_ERROR') {
@@ -12,8 +13,8 @@ function text(value, label, max = 1048576) {
     check(isTextWithinLimit(value, max), `Invalid ${label}.`);
 }
 
-/** Validate the Decisions wire contract independently of the common API limits. */
-export function validateDecisionRequest(input, defaultModel = 'gpt-6-luna') {
+/** Validate native fields while retaining the selected model for preparation and metadata. */
+export function validateDecisionRequest(input, defaultModel = OPENAI_DEFAULT_MODEL) {
     const request = cloneJson(input, 'native decision request');
     fields(request, ['input', 'model', 'questions', 'safety_identifier'], ['input', 'questions'], 'decision request');
     const model = request.model ?? defaultModel;

package/src/providers/openai-decisions.mjs

@@ -5,8 +5,9 @@ import { builtInCapabilities } from '../capabilities.mjs';
 import { JsonTransport, parseBaseURL, validateApiKey } from '../transport.mjs';
 import { environmentValue } from '../runtime-env.mjs';
 import { validateDecisionResponse } from './decisions-validation.mjs';
-import { encodeCommonDecision, decodeCommonDecision } from './decisions-codec.mjs';
-import { preflightCommonDecision, preflightDecision } from './decisions-preflight.mjs';
+import { decodeCommonDecision } from './decisions-codec.mjs';
+import { preflightCommonDecision, prepareCommonDecision, prepareDecision } from './decisions-preflight.mjs';
+import { OPENAI_DEFAULT_MODEL } from './openai-profile.mjs';
 
 /** Native Decisions transport. Common and dedicated access share a single codec. */
 export class OpenAIDecisionsProvider {
@@ -17,7 +18,7 @@ export class OpenAIDecisionsProvider {
     #maxRequestBytes;
 
     constructor(options = {}) {
-        const { apiKey, model = 'gpt-6-luna', baseURL = 'https://api.openai.com', maxRetries = 0, ...transportOptions } =
+        const { apiKey, model = OPENAI_DEFAULT_MODEL, baseURL = 'https://api.openai.com', maxRetries = 0, ...transportOptions } =
             optionsObject(options, ['apiKey', 'model', 'baseURL', ...TRANSPORT_FIELDS], 'OpenAI Decisions options');
         const endpoint = parseBaseURL(baseURL, { originOnly: true });
         const supplied = apiKey === undefined && endpoint.origin === 'https://api.openai.com'
@@ -36,16 +37,22 @@ export class OpenAIDecisionsProvider {
         preflightCommonDecision(request, { model: this.defaultModel, maxRequestBytes: this.#maxRequestBytes });
     }
 
-    async createDecision(input, options = {}) {
-        const request = preflightDecision(input, { model: this.defaultModel, maxRequestBytes: this.#maxRequestBytes });
-        const { data, meta } = await this.#transport.request('POST', '/v1/decisions', request, options);
-        const decision = withResponseMeta(meta, () => validateDecisionResponse(data, request));
+    /** Dispatch only prepared wire input; keep selection and reported identity independent. */
+    async #perform({ request, native }, options) {
+        const { data, meta: transport } = await this.#transport.request('POST', '/v1/decisions', native, options);
+        const meta = { ...transport, requestedModel: request.model, resolvedModel: native.model };
+        const decision = withResponseMeta(meta, () => validateDecisionResponse(data, native));
         return freezeJson({ decision, meta });
     }
 
+    async createDecision(input, options = {}) {
+        const prepared = prepareDecision(input, { model: this.defaultModel, maxRequestBytes: this.#maxRequestBytes });
+        return this.#perform(prepared, options);
+    }
+
     async evaluate(input, options = {}) {
-        const request = preflightCommonDecision(input, { model: this.defaultModel, maxRequestBytes: this.#maxRequestBytes });
-        const { decision, meta } = await this.createDecision(encodeCommonDecision(request), options);
-        return freezeJson(withResponseMeta(meta, () => decodeCommonDecision(decision, request, meta)));
+        const prepared = prepareCommonDecision(input, { model: this.defaultModel, maxRequestBytes: this.#maxRequestBytes });
+        const { decision, meta } = await this.#perform(prepared, options);
+        return freezeJson(withResponseMeta(meta, () => decodeCommonDecision(decision, prepared.request, meta)));
     }
 }

package/src/providers/openai-profile.mjs

@@ -0,0 +1,24 @@
+import { requireCondition as check } from '../errors.mjs';
+
+/** Release-owned selectors resolve locally; upstream responses never change this mapping. */
+export const OPENAI_DEFAULT_MODEL = 'default';
+const LUNA_MODEL = 'gpt-6-luna';
+const SELECTORS = Object.freeze({ default: LUNA_MODEL, luna: LUNA_MODEL, [LUNA_MODEL]: LUNA_MODEL });
+const PROFILES = Object.freeze({
+    [LUNA_MODEL]: Object.freeze({
+        supported: true, orderedInput: true, images: true, typedChoices: true,
+        labeledScores: true, safetyIdentifier: true,
+        maxImages: 128, maxChoiceOptions: 255, maxScoreLevels: null,
+    }),
+});
+
+/** Lookup does not throw for unsupported selections, matching capability-query semantics. */
+export function openaiModelProfile(selector) {
+    return typeof selector === 'string' && Object.hasOwn(SELECTORS, selector)
+        ? PROFILES[SELECTORS[selector]] : undefined;
+}
+
+export function resolveOpenAIModel(selector) {
+    check(openaiModelProfile(selector), 'Selected provider/model does not support this model.', 'UNSUPPORTED_CAPABILITY');
+    return SELECTORS[selector];
+}

package/src/version.mjs

@@ -1,2 +1,2 @@
 /** Keep in sync with package.json; scripts/check.mjs verifies the release version. */
-export const VERSION = '0.1.0';
+export const VERSION = '0.1.1';